diff --git a/backend/s3/client.go b/backend/s3/client.go
new file mode 100644
index 00000000..b0a02284
--- /dev/null
+++ b/backend/s3/client.go
@@ -0,0 +1,19 @@
+package s3
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+)
+
+type Client interface {
+	manager.DownloadAPIClient
+	manager.UploadAPIClient
+	CopyObject(ctx context.Context, in *s3.CopyObjectInput, opts ...func(*s3.Options)) (*s3.CopyObjectOutput, error)
+	DeleteObject(ctx context.Context, in *s3.DeleteObjectInput, opts ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)
+	HeadBucket(ctx context.Context, in *s3.HeadBucketInput, opts ...func(*s3.Options)) (*s3.HeadBucketOutput, error)
+	HeadObject(ctx context.Context, in *s3.HeadObjectInput, opts ...func(*s3.Options)) (*s3.HeadObjectOutput, error)
+	ListObjects(ctx context.Context, in *s3.ListObjectsInput, opts ...func(*s3.Options)) (*s3.ListObjectsOutput, error)
+	ListObjectVersions(ctx context.Context, in *s3.ListObjectVersionsInput, opts ...func(*s3.Options)) (*s3.ListObjectVersionsOutput, error)
+}
diff --git a/backend/s3/doc.go b/backend/s3/doc.go
index 13cbd6c9..3865dfad 100644
--- a/backend/s3/doc.go
+++ b/backend/s3/doc.go
@@ -44,12 +44,12 @@ would have to be cast as s3.FileSystem to use the following:
 	    )
 
 	    // to pass specific client, for instance a mock client
-	    s3apiMock := &mocks.S3API{}
-	    s3apiMock.On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).
+	    s3cliMock := &mocks.Client{}
+	    s3cliMock.On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
 	        Return(&s3.GetObjectOutput{
 	            Body: nopCloser{bytes.NewBufferString("Hello world!")},
 	            }, nil)
-	    fs = fs.WithClient(s3apiMock)
+	    fs = fs.WithClient(s3cliMock)
 	}
 
 # Object ACL
@@ -86,6 +86,6 @@ and https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.ht
 
 # See Also
 
-See: https://github.com/aws/aws-sdk-go/tree/master/service/s3
+See: https://github.com/aws/aws-sdk-go-v2/tree/main/service/s3
 */
 package s3
diff --git a/backend/s3/file.go b/backend/s3/file.go
index 4592aebb..e8dbf61c 100644
--- a/backend/s3/file.go
+++ b/backend/s3/file.go
@@ -11,11 +11,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3iface"
-	"github.com/aws/aws-sdk-go/service/s3/s3manager"
-	"github.com/aws/aws-sdk-go/service/s3/s3manager/s3manageriface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
 
 	"github.com/c2fo/vfs/v6"
 	"github.com/c2fo/vfs/v6/mocks"
@@ -132,17 +131,14 @@ func (f *File) CopyToFile(file vfs.File) (err error) {
 
 	// if target is S3
 	if tf, ok := file.(*File); ok {
-		input, err := f.getCopyObjectInput(tf)
-		if err != nil {
-			return err
-		}
+		input := f.getCopyObjectInput(tf)
 		// if input is not nil, use it to natively copy object
 		if input != nil {
 			client, err := f.fileSystem.Client()
 			if err != nil {
 				return err
 			}
-			_, err = client.CopyObject(input)
+			_, err = client.CopyObject(context.Background(), input)
 			return err
 		}
 	}
@@ -225,7 +221,7 @@ func (f *File) Delete(opts ...options.DeleteOption) error {
 		}
 	}
 
-	_, err = client.DeleteObject(&s3.DeleteObjectInput{
+	_, err = client.DeleteObject(context.Background(), &s3.DeleteObjectInput{
 		Key:    &f.key,
 		Bucket: &f.bucket,
 	})
@@ -240,7 +236,7 @@ func (f *File) Delete(opts ...options.DeleteOption) error {
 		}
 
 		for _, version := range objectVersions.Versions {
-			if _, err = client.DeleteObject(&s3.DeleteObjectInput{
+			if _, err = client.DeleteObject(context.Background(), &s3.DeleteObjectInput{
 				Key:       &f.key,
 				Bucket:    &f.bucket,
 				VersionId: version.VersionId,
@@ -338,11 +334,11 @@ func (f *File) tempToS3() error {
 		return err
 	}
 
-	uploader := getUploader(client, withUploadPartitionSize(f.getDownloadPartitionSize()))
+	uploader := manager.NewUploader(client, withUploadPartitionSize(f.getUploadPartitionSize()))
 	uploadInput := uploadInput(f)
 	uploadInput.Body = f.tempFileWriter
 
-	_, err = uploader.UploadWithContext(context.Background(), uploadInput)
+	_, err = uploader.Upload(context.Background(), uploadInput)
 	if err != nil {
 		return err
 	}
@@ -544,9 +540,9 @@ func (f *File) String() string {
 /*
 Private helper functions
 */
-func (f *File) getAllObjectVersions(client s3iface.S3API) (*s3.ListObjectVersionsOutput, error) {
+func (f *File) getAllObjectVersions(client Client) (*s3.ListObjectVersionsOutput, error) {
 	prefix := utils.RemoveLeadingSlash(f.key)
-	objVers, err := client.ListObjectVersions(&s3.ListObjectVersionsInput{
+	objVers, err := client.ListObjectVersions(context.Background(), &s3.ListObjectVersionsInput{
 		Bucket: &f.bucket,
 		Prefix: &prefix,
 	})
@@ -554,22 +550,25 @@ func (f *File) getAllObjectVersions(client s3iface.S3API) (*s3.ListObjectVersion
 }
 
 func (f *File) getHeadObject() (*s3.HeadObjectOutput, error) {
-	headObjectInput := new(s3.HeadObjectInput).SetKey(f.key).SetBucket(f.bucket)
+	headObjectInput := &s3.HeadObjectInput{
+		Key:    aws.String(f.key),
+		Bucket: aws.String(f.bucket),
+	}
 	client, err := f.fileSystem.Client()
 	if err != nil {
 		return nil, err
 	}
 
-	head, err := client.HeadObject(headObjectInput)
+	head, err := client.HeadObject(context.Background(), headObjectInput)
 
 	return head, handleExistsError(err)
 }
 
 // For copy from S3-to-S3 when credentials are the same between source and target, return *s3.CopyObjectInput or error
-func (f *File) getCopyObjectInput(targetFile *File) (*s3.CopyObjectInput, error) {
+func (f *File) getCopyObjectInput(targetFile *File) *s3.CopyObjectInput {
 	// first we must determine if we're using the same s3 credentials for source and target before doing a native copy
 	isSameAccount := false
-	var ACL string
+	var ACL types.ObjectCannedACL
 
 	// get content type from source
 	var contentType string
@@ -612,12 +611,13 @@ func (f *File) getCopyObjectInput(targetFile *File) (*s3.CopyObjectInput, error)
 		// PathEscape ensures we url-encode as required by the API, including double-encoding literals
 		copySourceKey := url.PathEscape(path.Join(f.bucket, f.key))
 
-		copyInput := new(s3.CopyObjectInput).
-			SetServerSideEncryption("AES256").
-			SetACL(ACL).
-			SetKey(targetFile.key).
-			SetBucket(targetFile.bucket).
-			SetCopySource(copySourceKey)
+		copyInput := &s3.CopyObjectInput{
+			ServerSideEncryption: types.ServerSideEncryptionAes256,
+			ACL:                  ACL,
+			Key:                  aws.String(targetFile.key),
+			Bucket:               aws.String(targetFile.bucket),
+			CopySource:           aws.String(copySourceKey),
+		}
 
 		// set content type if it exists
 		if contentType != "" {
@@ -625,19 +625,14 @@ func (f *File) getCopyObjectInput(targetFile *File) (*s3.CopyObjectInput, error)
 		}
 
 		if f.fileSystem.options != nil && f.fileSystem.options.(Options).DisableServerSideEncryption {
-			copyInput.ServerSideEncryption = nil
-		}
-
-		// validate copyInput
-		if err := copyInput.Validate(); err != nil {
-			return nil, err
+			copyInput.ServerSideEncryption = ""
 		}
 
-		return copyInput, nil
+		return copyInput
 	}
 
 	// return nil if credentials aren't the same
-	return nil, nil
+	return nil
 }
 
 func (f *File) copyS3ToLocalTempReader(tmpFile *os.File) error {
@@ -647,21 +642,23 @@ func (f *File) copyS3ToLocalTempReader(tmpFile *os.File) error {
 	}
 
 	// Download file
-	input := new(s3.GetObjectInput).SetBucket(f.bucket).SetKey(f.key)
+	input := &s3.GetObjectInput{
+		Bucket: aws.String(f.bucket),
+		Key:    aws.String(f.key),
+	}
 	opt := withDownloadPartitionSize(f.getDownloadPartitionSize())
-	_, err = getDownloader(client, opt).
-		DownloadWithContext(context.Background(), tmpFile, input)
+	_, err = manager.NewDownloader(client, opt).
+		Download(context.Background(), tmpFile, input)
 
 	return err
 }
 
 // TODO: need to provide an implementation-agnostic container for providing config options such as SSE
-func uploadInput(f *File) *s3manager.UploadInput {
-	sseType := "AES256"
-	input := &s3manager.UploadInput{
+func uploadInput(f *File) *s3.PutObjectInput {
+	input := &s3.PutObjectInput{
 		Bucket:               &f.bucket,
 		Key:                  &f.key,
-		ServerSideEncryption: &sseType,
+		ServerSideEncryption: types.ServerSideEncryptionAes256,
 	}
 
 	if f.fileSystem.options == nil {
@@ -669,12 +666,12 @@ func uploadInput(f *File) *s3manager.UploadInput {
 	}
 
 	if f.fileSystem.options.(Options).DisableServerSideEncryption {
-		input.ServerSideEncryption = nil
+		input.ServerSideEncryption = ""
 	}
 
 	if opts, ok := f.fileSystem.options.(Options); ok {
 		if opts.ACL != "" {
-			input.ACL = &opts.ACL
+			input.ACL = opts.ACL
 		}
 	}
 
@@ -743,10 +740,11 @@ func (f *File) getReader() (io.ReadCloser, error) {
 				f.reader = io.NopCloser(strings.NewReader(""))
 			} else {
 				// Create the request to get the object
-				input := new(s3.GetObjectInput).
-					SetBucket(f.bucket).
-					SetKey(f.key).
-					SetRange(fmt.Sprintf("bytes=%d-", f.cursorPos))
+				input := &s3.GetObjectInput{
+					Bucket: aws.String(f.bucket),
+					Key:    aws.String(f.key),
+					Range:  aws.String(fmt.Sprintf("bytes=%d-", f.cursorPos)),
+				}
 
 				// Get the client
 				client, err := f.fileSystem.Client()
@@ -755,7 +753,7 @@ func (f *File) getReader() (io.ReadCloser, error) {
 				}
 
 				// Request the object
-				result, err := client.GetObject(input)
+				result, err := client.GetObject(context.Background(), input)
 				if err != nil {
 					return nil, err
 				}
@@ -770,12 +768,9 @@ func (f *File) getReader() (io.ReadCloser, error) {
 
 func handleExistsError(err error) error {
 	if err != nil {
-		var awsErr awserr.Error
-		if errors.As(err, &awsErr) {
-			switch awsErr.Code() {
-			case s3.ErrCodeNoSuchKey, s3.ErrCodeNoSuchBucket, "NotFound":
-				return vfs.ErrNotExist
-			}
+		var kerr *types.NoSuchKey
+		if errors.As(err, &kerr) {
+			return vfs.ErrNotExist
 		}
 		return err
 	}
@@ -828,15 +823,15 @@ func (f *File) getS3Writer() (*io.PipeWriter, error) {
 	if err != nil {
 		return nil, err
 	}
-	uploader := getUploader(client, withUploadPartitionSize(f.getUploadPartitionSize()))
+	uploader := manager.NewUploader(client, withUploadPartitionSize(f.getUploadPartitionSize()))
 	ctx, cancel := context.WithCancel(context.Background())
 	f.cancelFunc = cancel
 	uploadInput := uploadInput(f)
 	uploadInput.Body = pr
 
-	go func(input *s3manager.UploadInput) {
+	go func(input *s3.PutObjectInput) {
 		defer cancel()
-		_, err := uploader.UploadWithContext(ctx, input)
+		_, err := uploader.Upload(ctx, input)
 		if err != nil {
 			_ = pw.CloseWithError(err)
 		}
@@ -870,22 +865,14 @@ func (f *File) getDownloadPartitionSize() int64 {
 	return partSize
 }
 
-func withDownloadPartitionSize(partSize int64) func(*s3manager.Downloader) {
-	return func(d *s3manager.Downloader) {
+func withDownloadPartitionSize(partSize int64) func(*manager.Downloader) {
+	return func(d *manager.Downloader) {
 		d.PartSize = partSize
 	}
 }
 
-func withUploadPartitionSize(partSize int64) func(*s3manager.Uploader) {
-	return func(u *s3manager.Uploader) {
+func withUploadPartitionSize(partSize int64) func(*manager.Uploader) {
+	return func(u *manager.Uploader) {
 		u.PartSize = partSize
 	}
 }
-
-var getDownloader = func(client s3iface.S3API, opts ...func(d *s3manager.Downloader)) s3manageriface.DownloaderAPI {
-	return s3manager.NewDownloaderWithClient(client, opts...)
-}
-
-var getUploader = func(client s3iface.S3API, opts ...func(d *s3manager.Uploader)) s3manageriface.UploaderAPI {
-	return s3manager.NewUploaderWithClient(client, opts...)
-}
diff --git a/backend/s3/fileSystem.go b/backend/s3/fileSystem.go
index ade41f98..ac98bef7 100644
--- a/backend/s3/fileSystem.go
+++ b/backend/s3/fileSystem.go
@@ -5,9 +5,6 @@ import (
 	"fmt"
 	"path"
 
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3iface"
-
 	"github.com/c2fo/vfs/v6"
 	"github.com/c2fo/vfs/v6/backend"
 	"github.com/c2fo/vfs/v6/options"
@@ -20,7 +17,7 @@ const name = "AWS S3"
 
 // FileSystem implements vfs.FileSystem for the S3 file system.
 type FileSystem struct {
-	client  s3iface.S3API
+	client  Client
 	options vfs.Options
 }
 
@@ -81,7 +78,7 @@ func (fs *FileSystem) Scheme() string {
 
 // Client returns the underlying aws s3 client, creating it, if necessary
 // See Overview for authentication resolution
-func (fs *FileSystem) Client() (s3iface.S3API, error) {
+func (fs *FileSystem) Client() (Client, error) {
 	if fs.client == nil {
 		if fs.options == nil {
 			fs.options = Options{}
@@ -113,15 +110,14 @@ func (fs *FileSystem) WithOptions(opts vfs.Options) *FileSystem {
 
 // WithClient passes in an s3 client and returns the file system (chainable)
 func (fs *FileSystem) WithClient(client interface{}) *FileSystem {
-	switch client.(type) {
-	case *s3.S3, s3iface.S3API:
-		fs.client = client.(s3iface.S3API)
+	if c, ok := client.(Client); ok {
+		fs.client = c
 		fs.options = nil
 	}
 	return fs
 }
 
-// NewFileSystem initializer for FileSystem struct accepts aws-sdk S3API client and returns FileSystem or error.
+// NewFileSystem initializer for FileSystem struct accepts aws-sdk client and returns Filesystem or error.
 func NewFileSystem() *FileSystem {
 	return &FileSystem{}
 }
diff --git a/backend/s3/fileSystem_test.go b/backend/s3/fileSystem_test.go
index 77ddc1ce..818c0737 100644
--- a/backend/s3/fileSystem_test.go
+++ b/backend/s3/fileSystem_test.go
@@ -1,10 +1,11 @@
 package s3
 
 import (
+	"context"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/c2fo/vfs/v6/utils"
@@ -19,17 +20,20 @@ var (
 )
 
 type mockClient struct {
-	*s3.S3
+	*s3.Client
 }
 
 func (ts *fileSystemTestSuite) SetupTest() {
-	sess := session.Must(session.NewSession())
-	client := mockClient{s3.New(sess)}
+	cfg, err := config.LoadDefaultConfig(context.Background())
+	if err != nil {
+		panic(err)
+	}
+	client := mockClient{s3.NewFromConfig(cfg)}
 	s3fs = &FileSystem{client: client}
 }
 
 func (ts *fileSystemTestSuite) TestNewFileSystem() {
-	newFS := NewFileSystem().WithClient(s3apiMock)
+	newFS := NewFileSystem().WithClient(s3cliMock)
 	ts.NotNil(newFS, "Should return a new fileSystem for s3")
 }
 
diff --git a/backend/s3/file_test.go b/backend/s3/file_test.go
index 9d3d8f98..e4da140a 100644
--- a/backend/s3/file_test.go
+++ b/backend/s3/file_test.go
@@ -6,17 +6,13 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"os"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3iface"
-	"github.com/aws/aws-sdk-go/service/s3/s3manager"
-	"github.com/aws/aws-sdk-go/service/s3/s3manager/s3manageriface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 
@@ -33,19 +29,20 @@ type fileTestSuite struct {
 }
 
 var (
-	s3apiMock      *mocks.S3API
+	s3cliMock      *mocks.Client
 	fs             FileSystem
 	testFile       vfs.File
 	defaultOptions Options
 	testFileName   string
 	bucket         string
+	matchContext   = mock.MatchedBy(func(context.Context) bool { return true })
 )
 
 func (ts *fileTestSuite) SetupTest() {
 	var err error
-	s3apiMock = &mocks.S3API{}
+	s3cliMock = &mocks.Client{}
 	defaultOptions = Options{AccessKeyID: "abc"}
-	fs = FileSystem{client: s3apiMock, options: defaultOptions}
+	fs = FileSystem{client: s3cliMock, options: defaultOptions}
 	testFileName = "/some/path/to/file.txt"
 	bucket = "bucket"
 	testFile, err = fs.NewFile(bucket, testFileName)
@@ -62,12 +59,12 @@ func (ts *fileTestSuite) TestRead() {
 	ts.Require().NoError(err, "Shouldn't fail creating new file")
 
 	var localFile = bytes.NewBuffer([]byte{})
-	s3apiMock.
-		On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
+	s3cliMock.
+		On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 		Return(&s3.HeadObjectOutput{ContentLength: aws.Int64(12)}, nil).
 		Twice()
-	s3apiMock.
-		On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).
+	s3cliMock.
+		On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
 		Return(&s3.GetObjectOutput{Body: io.NopCloser(strings.NewReader(contents))}, nil).
 		Once()
 	_, copyErr := io.Copy(localFile, file)
@@ -78,12 +75,12 @@ func (ts *fileTestSuite) TestRead() {
 
 	// test read with error
 	someErr := errors.New("some error")
-	s3apiMock.
-		On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
+	s3cliMock.
+		On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 		Return(&s3.HeadObjectOutput{ContentLength: aws.Int64(12)}, nil).
 		Once()
-	s3apiMock.
-		On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).
+	s3cliMock.
+		On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
 		Return(nil, someErr).
 		Once()
 	_, copyErr = io.Copy(localFile, file)
@@ -128,8 +125,8 @@ func (ts *fileTestSuite) TestSeek() {
 
 	for _, tc := range testCases {
 		ts.Run(fmt.Sprintf("SeekOffset %d Whence %d", tc.seekOffset, tc.seekWhence), func() {
-			m := s3apiMock.
-				On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
+			m := s3cliMock.
+				On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 				Return(headOutput, nil)
 			if !tc.expectedErr {
 				m.Twice()
@@ -144,11 +141,11 @@ func (ts *fileTestSuite) TestSeek() {
 				ts.Equal(tc.expectedPos, pos, "Expected position does not match for seek offset %d and whence %d", tc.seekOffset, tc.seekWhence)
 
 				// Mock the GetObject call
-				s3apiMock.
-					On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
+				s3cliMock.
+					On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 					Return(headOutput, nil).
 					Once()
-				s3apiMock.On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).
+				s3cliMock.On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
 					Return(&s3.GetObjectOutput{Body: io.NopCloser(strings.NewReader(tc.readContent))}, nil).
 					Once()
 
@@ -160,11 +157,11 @@ func (ts *fileTestSuite) TestSeek() {
 	}
 
 	// test fails with Size error
-	s3apiMock := &mocks.S3API{}
-	fs.client = s3apiMock
-	s3apiMock.
-		On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
-		Return(nil, awserr.New("NotFound", "file does not exist", os.ErrNotExist)).
+	s3cliMock := &mocks.Client{}
+	fs.client = s3cliMock
+	s3cliMock.
+		On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
+		Return(nil, &types.NoSuchKey{}).
 		Once()
 	_, err = file.Seek(0, 0)
 	ts.Require().Error(err, "error expected")
@@ -211,7 +208,7 @@ func (ts *fileTestSuite) TestExists() {
 	file, err := fs.NewFile("bucket", "/path/hello.txt")
 	ts.Require().NoError(err, "Shouldn't fail creating new file.")
 
-	s3apiMock.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
+	s3cliMock.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
 
 	exists, err := file.Exists()
 	ts.True(exists, "Should return true for exists based on this setup")
@@ -222,8 +219,8 @@ func (ts *fileTestSuite) TestNotExists() {
 	file, err := fs.NewFile("bucket", "/path/hello.txt")
 	ts.Require().NoError(err, "Shouldn't fail creating new file.")
 
-	s3apiMock.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
-		Return(&s3.HeadObjectOutput{}, awserr.New(s3.ErrCodeNoSuchKey, "key doesn't exist", nil))
+	s3cliMock.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
+		Return(&s3.HeadObjectOutput{}, &types.NoSuchKey{})
 
 	exists, err := file.Exists()
 	ts.False(exists, "Should return false for exists based on setup")
@@ -233,25 +230,25 @@ func (ts *fileTestSuite) TestNotExists() {
 func (ts *fileTestSuite) TestCopyToFile() {
 	targetFile := &File{
 		fileSystem: &FileSystem{
-			client:  s3apiMock,
+			client:  s3cliMock,
 			options: defaultOptions,
 		},
 		bucket: "TestBucket",
 		key:    "testKey.txt",
 	}
 
-	s3apiMock.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
+	s3cliMock.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
 
 	err := testFile.CopyToFile(targetFile)
 	ts.NoError(err, "Error shouldn't be returned from successful call to CopyToFile")
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 
 	// Test With Non Minimum Buffer Size in TouchCopyBuffered
 	originalBufferSize := defaultOptions.FileBufferSize
 	defaultOptions.FileBufferSize = 2 * utils.TouchCopyMinBufferSize
 	targetFile = &File{
 		fileSystem: &FileSystem{
-			client:  s3apiMock,
+			client:  s3cliMock,
 			options: defaultOptions,
 		},
 		bucket: "TestBucket",
@@ -259,23 +256,23 @@ func (ts *fileTestSuite) TestCopyToFile() {
 	}
 	defaultOptions.FileBufferSize = originalBufferSize
 
-	s3apiMock.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
+	s3cliMock.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
 
 	err = testFile.CopyToFile(targetFile)
 	ts.NoError(err, "Error shouldn't be returned from successful call to CopyToFile")
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestEmptyCopyToFile() {
 	targetFile := &vfsmocks.File{}
 	targetFile.On("Write", mock.Anything).Return(0, nil)
 	targetFile.On("Close").Return(nil)
-	s3apiMock.
-		On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
+	s3cliMock.
+		On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 		Return(&s3.HeadObjectOutput{ContentLength: aws.Int64(0)}, nil).
 		Twice()
-	s3apiMock.
-		On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).
+	s3cliMock.
+		On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
 		Return(&s3.GetObjectOutput{Body: io.NopCloser(strings.NewReader(""))}, nil).
 		Once()
 	err := testFile.CopyToFile(targetFile)
@@ -288,19 +285,19 @@ func (ts *fileTestSuite) TestEmptyCopyToFile() {
 func (ts *fileTestSuite) TestMoveToFile() {
 	targetFile := &File{
 		fileSystem: &FileSystem{
-			client:  s3apiMock,
+			client:  s3cliMock,
 			options: defaultOptions,
 		},
 		bucket: "TestBucket",
 		key:    "testKey.txt",
 	}
 
-	s3apiMock.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
-	s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	s3cliMock.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
+	s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 
 	err := testFile.MoveToFile(targetFile)
 	ts.NoError(err, "Error shouldn't be returned from successful call to MoveToFile")
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestGetCopyObject() {
@@ -335,7 +332,7 @@ func (ts *fileTestSuite) TestGetCopyObject() {
 		ts.Run(fmt.Sprintf("%d", i), func() {
 			sourceFile := &File{
 				fileSystem: &FileSystem{
-					client: s3apiMock,
+					client: s3cliMock,
 					options: Options{
 						AccessKeyID:                 "abc",
 						DisableServerSideEncryption: true,
@@ -347,7 +344,7 @@ func (ts *fileTestSuite) TestGetCopyObject() {
 
 			targetFile := &File{
 				fileSystem: &FileSystem{
-					client: s3apiMock,
+					client: s3cliMock,
 					options: Options{
 						AccessKeyID: "abc",
 					},
@@ -357,10 +354,9 @@ func (ts *fileTestSuite) TestGetCopyObject() {
 			}
 
 			// copy from t.key to /source.txt
-			actual, err := sourceFile.getCopyObjectInput(targetFile)
-			ts.NoError(err, "Error shouldn't be returned from successful call to CopyToFile")
+			actual := sourceFile.getCopyObjectInput(targetFile)
 			ts.Equal("TestBucket"+t.expectedCopySource, *actual.CopySource)
-			ts.Nil(actual.ServerSideEncryption, "sse is disabled")
+			ts.Empty(actual.ServerSideEncryption, "sse is disabled")
 		})
 	}
 
@@ -368,7 +364,7 @@ func (ts *fileTestSuite) TestGetCopyObject() {
 	// nil means we can't do s3-to-s3 copy so use TouchCopy
 	sourceFile := &File{
 		fileSystem: &FileSystem{
-			client:  s3apiMock,
+			client:  s3cliMock,
 			options: defaultOptions,
 		},
 		bucket: "TestBucket",
@@ -377,7 +373,7 @@ func (ts *fileTestSuite) TestGetCopyObject() {
 
 	targetFile := &File{
 		fileSystem: &FileSystem{
-			client: s3apiMock,
+			client: s3cliMock,
 			options: Options{
 				AccessKeyID: "xyz",
 				ACL:         "SomeCannedACL",
@@ -386,37 +382,36 @@ func (ts *fileTestSuite) TestGetCopyObject() {
 		bucket: "TestBucket",
 		key:    "/path/to/otherFile.txt",
 	}
-	actual, err := sourceFile.getCopyObjectInput(targetFile)
-	ts.NoError(err, "Error shouldn't be returned from successful call to CopyToFile")
+	actual := sourceFile.getCopyObjectInput(targetFile)
 	ts.Nil(actual, "copyObjectInput should be nil (can't do s3-to-s3 copyObject)")
 
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestMoveToFile_CopyError() {
 	targetFile := &File{
 		fileSystem: &FileSystem{
-			client:  s3apiMock,
+			client:  s3cliMock,
 			options: defaultOptions,
 		},
 		bucket: "TestBucket",
 		key:    "testKey.txt",
 	}
 
-	s3apiMock.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, errors.New("some copy error"))
+	s3cliMock.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, errors.New("some copy error"))
 
 	err := testFile.MoveToFile(targetFile)
 	ts.Error(err, "Error shouldn't be returned from successful call to CopyToFile")
-	s3apiMock.AssertNotCalled(ts.T(), "DeleteObject", mock.Anything)
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertNotCalled(ts.T(), "DeleteObject", mock.Anything)
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestCopyToLocation() {
-	s3Mock1 := &mocks.S3API{}
+	s3Mock1 := &mocks.Client{}
 	fooReader := io.NopCloser(strings.NewReader("blah"))
-	s3Mock1.On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).Return(&s3.GetObjectOutput{Body: fooReader}, nil)
-	s3Mock1.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, nil)
-	s3Mock1.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
+	s3Mock1.On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).Return(&s3.GetObjectOutput{Body: fooReader}, nil)
+	s3Mock1.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, nil)
+	s3Mock1.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
 	f := &File{
 		fileSystem: &FileSystem{
 			client:  s3Mock1,
@@ -433,7 +428,7 @@ func (ts *fileTestSuite) TestCopyToLocation() {
 
 	l := &Location{
 		fileSystem: &FileSystem{
-			client:  &mocks.S3API{},
+			client:  &mocks.Client{},
 			options: defaultOptions,
 		},
 		bucket: "bucket",
@@ -449,10 +444,10 @@ func (ts *fileTestSuite) TestTouch() {
 	// Copy portion tested through CopyToLocation, just need to test whether Delete happens
 	// in addition to CopyToLocation
 
-	s3Mock1 := &mocks.S3API{}
-	s3Mock1.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
-	s3Mock1.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, nil)
-	s3Mock1.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	s3Mock1 := &mocks.Client{}
+	s3Mock1.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
+	s3Mock1.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, nil)
+	s3Mock1.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 
 	file := &File{
 		fileSystem: &FileSystem{
@@ -469,10 +464,10 @@ func (ts *fileTestSuite) TestTouch() {
 	s3Mock1.AssertExpectations(ts.T())
 
 	// test non-existent length
-	s3Mock2 := &mocks.S3API{}
-	s3Mock2.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
-		Return(&s3.HeadObjectOutput{}, awserr.New(s3.ErrCodeNoSuchKey, "", nil)).Once()
-	s3Mock2.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
+	s3Mock2 := &mocks.Client{}
+	s3Mock2.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
+		Return(&s3.HeadObjectOutput{}, &types.NoSuchKey{}).Once()
+	s3Mock2.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 		Return(&s3.HeadObjectOutput{}, nil)
 	file2 := &File{
 		fileSystem: &FileSystem{
@@ -482,24 +477,10 @@ func (ts *fileTestSuite) TestTouch() {
 		bucket: "newBucket",
 		key:    "/new/file/path/hello.txt",
 	}
-	oldfunc := getUploader
-
-	defer func() { getUploader = oldfunc }()
-	getUploader = func(client s3iface.S3API, opts ...func(d *s3manager.Uploader)) s3manageriface.UploaderAPI {
-		u := mocks.NewUploaderAPI(ts.T())
-		u.EXPECT().
-			UploadWithContext(mock.Anything, mock.AnythingOfType("*s3manager.UploadInput"), mock.Anything).
-			RunAndReturn(func(ctx context.Context,
-				input *s3manager.UploadInput, opts ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
-				// Read from the input.Body (which is a PipeReader) to simulate actual upload
-				_, readErr := io.ReadAll(input.Body)
-				if readErr != nil {
-					return nil, readErr
-				}
-				return &s3manager.UploadOutput{}, nil
-			})
-		return u
-	}
+
+	s3Mock2.On("PutObject", matchContext, mock.AnythingOfType("*s3.PutObjectInput"), mock.Anything, mock.Anything).
+		Return(&s3.PutObjectOutput{}, nil)
+
 	terr2 := file2.Touch()
 	ts.NoError(terr2, "Shouldn't return error creating test s3.File instance.")
 
@@ -509,9 +490,9 @@ func (ts *fileTestSuite) TestTouch() {
 func (ts *fileTestSuite) TestMoveToLocation() {
 	// Copy portion tested through CopyToLocation, just need to test whether Delete happens
 	// in addition to CopyToLocation
-	s3Mock1 := &mocks.S3API{}
-	s3Mock1.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, nil)
-	s3Mock1.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
+	s3Mock1 := &mocks.Client{}
+	s3Mock1.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, nil)
+	s3Mock1.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{}, nil)
 	f := &File{
 		fileSystem: &FileSystem{
 			client:  s3Mock1,
@@ -523,8 +504,8 @@ func (ts *fileTestSuite) TestMoveToLocation() {
 	location := new(vfsmocks.Location)
 	location.On("NewFile", mock.Anything).Return(f, nil)
 
-	s3apiMock.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
-	s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	s3cliMock.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
+	s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 
 	file, err := fs.NewFile("bucket", "/hello.txt")
 	ts.Require().NoError(err, "Shouldn't return error creating test s3.File instance.")
@@ -542,17 +523,17 @@ func (ts *fileTestSuite) TestMoveToLocation() {
 	mockLocation.On("NewFile", mock.Anything).
 		Return(&File{fileSystem: &FileSystem{client: s3Mock1}, bucket: "bucket", key: "/new/hello.txt"}, nil)
 
-	s3apiMock2 := &mocks.S3API{}
-	s3apiMock2.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
+	s3cliMock2 := &mocks.Client{}
+	s3cliMock2.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(&s3.CopyObjectOutput{}, nil)
 
-	fs = FileSystem{client: s3apiMock2}
+	fs = FileSystem{client: s3cliMock2}
 	file2, err := fs.NewFile("bucket", "/hello.txt")
 	ts.Require().NoError(err, "Shouldn't return error creating test s3.File instance.")
 
 	_, err = file2.CopyToLocation(mockLocation)
 	ts.NoError(err, "MoveToLocation error not expected")
 
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 	location.AssertExpectations(ts.T())
 	mockLocation.AssertExpectations(ts.T())
 }
@@ -563,7 +544,7 @@ func (ts *fileTestSuite) TestMoveToLocationFail() {
 	location := new(vfsmocks.Location)
 	location.On("NewFile", mock.Anything).Return(&File{fileSystem: &fs, bucket: "bucket", key: "/new/hello.txt"}, nil)
 
-	s3apiMock.On("CopyObject", mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, errors.New("didn't copy, oh noes"))
+	s3cliMock.On("CopyObject", matchContext, mock.AnythingOfType("*s3.CopyObjectInput")).Return(nil, errors.New("didn't copy, oh noes"))
 
 	file, err := fs.NewFile("bucket", "/hello.txt")
 	ts.Require().NoError(err, "Shouldn't return error creating test s3.File instance.")
@@ -574,67 +555,69 @@ func (ts *fileTestSuite) TestMoveToLocationFail() {
 	closeErr := file.Close()
 	ts.NoError(closeErr, "no close error expected")
 
-	s3apiMock.AssertExpectations(ts.T())
-	s3apiMock.AssertNotCalled(ts.T(), "DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput"))
+	s3cliMock.AssertExpectations(ts.T())
+	s3cliMock.AssertNotCalled(ts.T(), "DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput"))
 	otherFs.AssertExpectations(ts.T())
 	location.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestDelete() {
-	s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 	err := testFile.Delete()
 	ts.NoError(err, "Successful delete should not return an error.")
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestDeleteError() {
-	s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(nil, errors.New("something went wrong"))
+	s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(nil, errors.New("something went wrong"))
 	err := testFile.Delete()
 	ts.EqualError(err, "something went wrong", "Delete should return an error if s3 api had error.")
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestDeleteWithAllVersionsOption() {
-	var versions []*s3.ObjectVersion
+	var versions []types.ObjectVersion
 	verIds := [...]string{"ver1", "ver2"}
 	for i := range verIds {
-		versions = append(versions, &s3.ObjectVersion{VersionId: &verIds[i]})
+		versions = append(versions, types.ObjectVersion{VersionId: &verIds[i]})
 	}
 	versOutput := s3.ListObjectVersionsOutput{
 		Versions: versions,
 	}
-	s3apiMock.On("ListObjectVersions", mock.AnythingOfType("*s3.ListObjectVersionsInput")).Return(&versOutput, nil)
-	s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	s3cliMock.On("ListObjectVersions", matchContext, mock.AnythingOfType("*s3.ListObjectVersionsInput")).Return(&versOutput, nil)
+	s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 
 	err := testFile.Delete(delete.WithAllVersions())
 	ts.NoError(err, "Successful delete should not return an error.")
-	s3apiMock.AssertExpectations(ts.T())
-	s3apiMock.AssertNumberOfCalls(ts.T(), "DeleteObject", 3)
+	s3cliMock.AssertExpectations(ts.T())
+	s3cliMock.AssertNumberOfCalls(ts.T(), "DeleteObject", 3)
 }
 
 func (ts *fileTestSuite) TestDeleteWithAllVersionsOptionError() {
-	var versions []*s3.ObjectVersion
+	var versions []types.ObjectVersion
 	verIds := [...]string{"ver1", "ver2"}
 	for i := range verIds {
-		versions = append(versions, &s3.ObjectVersion{VersionId: &verIds[i]})
+		versions = append(versions, types.ObjectVersion{VersionId: &verIds[i]})
 	}
 	versOutput := s3.ListObjectVersionsOutput{
 		Versions: versions,
 	}
-	s3apiMock.On("ListObjectVersions", mock.AnythingOfType("*s3.ListObjectVersionsInput")).Return(&versOutput, nil)
-	s3apiMock.On("DeleteObject", &s3.DeleteObjectInput{Key: &testFileName, Bucket: &bucket}).Return(&s3.DeleteObjectOutput{}, nil)
-	s3apiMock.On("DeleteObject", &s3.DeleteObjectInput{Key: &testFileName, Bucket: &bucket, VersionId: &verIds[0]}).
+	s3cliMock.On("ListObjectVersions", matchContext, mock.AnythingOfType("*s3.ListObjectVersionsInput")).
+		Return(&versOutput, nil)
+	s3cliMock.On("DeleteObject", matchContext, &s3.DeleteObjectInput{Key: &testFileName, Bucket: &bucket}).
+		Return(&s3.DeleteObjectOutput{}, nil)
+	s3cliMock.On("DeleteObject", matchContext, &s3.DeleteObjectInput{Key: &testFileName, Bucket: &bucket, VersionId: &verIds[0]}).
 		Return(nil, errors.New("something went wrong"))
 
 	err := testFile.Delete(delete.WithAllVersions())
 	ts.Error(err, "Delete should return an error if s3 api had error.")
-	s3apiMock.AssertExpectations(ts.T())
-	s3apiMock.AssertNumberOfCalls(ts.T(), "DeleteObject", 2)
+	s3cliMock.AssertExpectations(ts.T())
+	s3cliMock.AssertNumberOfCalls(ts.T(), "DeleteObject", 2)
 }
 
 func (ts *fileTestSuite) TestLastModified() {
 	now := time.Now()
-	s3apiMock.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{
+	s3cliMock.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{
 		LastModified: &now,
 	}, nil)
 	modTime, err := testFile.LastModified()
@@ -644,7 +627,7 @@ func (ts *fileTestSuite) TestLastModified() {
 
 func (ts *fileTestSuite) TestLastModifiedFail() {
 	// setup error on HEAD
-	s3apiMock.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(nil,
+	s3cliMock.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(nil,
 		errors.New("boom"))
 	m, e := testFile.LastModified()
 	ts.Error(e, "got error as expected")
@@ -657,14 +640,14 @@ func (ts *fileTestSuite) TestName() {
 
 func (ts *fileTestSuite) TestSize() {
 	contentLength := int64(100)
-	s3apiMock.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{
+	s3cliMock.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).Return(&s3.HeadObjectOutput{
 		ContentLength: &contentLength,
 	}, nil)
 
 	size, err := testFile.Size()
 	ts.NoError(err, "Error should be nil when requesting size for file that exists.")
 	ts.Equal(uint64(100), size, "Size should return the ContentLength value from s3 HEAD request.")
-	s3apiMock.AssertExpectations(ts.T())
+	s3cliMock.AssertExpectations(ts.T())
 }
 
 func (ts *fileTestSuite) TestPath() {
@@ -672,23 +655,23 @@ func (ts *fileTestSuite) TestPath() {
 }
 
 func (ts *fileTestSuite) TestURI() {
-	s3apiMock = &mocks.S3API{}
-	fs = FileSystem{client: s3apiMock}
+	s3cliMock = &mocks.Client{}
+	fs = FileSystem{client: s3cliMock}
 	file, _ := fs.NewFile("mybucket", "/some/file/test.txt")
 	expected := "s3://mybucket/some/file/test.txt"
 	ts.Equal(expected, file.URI(), "%s does not match %s", file.URI(), expected)
 }
 
 func (ts *fileTestSuite) TestStringer() {
-	fs = FileSystem{client: &mocks.S3API{}}
+	fs = FileSystem{client: &mocks.Client{}}
 	file, _ := fs.NewFile("mybucket", "/some/file/test.txt")
 	ts.Equal("s3://mybucket/some/file/test.txt", file.String())
 }
 
 func (ts *fileTestSuite) TestUploadInput() {
-	fs = FileSystem{client: &mocks.S3API{}}
+	fs = FileSystem{client: &mocks.Client{}}
 	file, _ := fs.NewFile("mybucket", "/some/file/test.txt")
-	ts.Equal("AES256", *uploadInput(file.(*File)).ServerSideEncryption, "sse was set")
+	ts.Equal(types.ServerSideEncryptionAes256, uploadInput(file.(*File)).ServerSideEncryption, "sse was set")
 	ts.Equal("/some/file/test.txt", *uploadInput(file.(*File)).Key, "key was set")
 	ts.Equal("mybucket", *uploadInput(file.(*File)).Bucket, "bucket was set")
 }
@@ -698,7 +681,7 @@ func (ts *fileTestSuite) TestUploadInputDisableSSE() {
 		WithOptions(Options{DisableServerSideEncryption: true})
 	file, _ := fs.NewFile("mybucket", "/some/file/test.txt")
 	input := uploadInput(file.(*File))
-	ts.Nil(input.ServerSideEncryption, "sse was disabled")
+	ts.Empty(input.ServerSideEncryption, "sse was disabled")
 	ts.Equal("/some/file/test.txt", *input.Key, "key was set")
 	ts.Equal("mybucket", *input.Bucket, "bucket was set")
 }
@@ -742,26 +725,11 @@ func (ts *fileTestSuite) TestCloseWithoutWrite() {
 }
 
 func (ts *fileTestSuite) TestCloseWithWrite() {
-	oldfunc := getUploader
-	defer func() { getUploader = oldfunc }()
-	getUploader = func(client s3iface.S3API, opts ...func(d *s3manager.Uploader)) s3manageriface.UploaderAPI {
-		u := mocks.NewUploaderAPI(ts.T())
-		u.EXPECT().
-			UploadWithContext(mock.Anything, mock.AnythingOfType("*s3manager.UploadInput"), mock.Anything).
-			RunAndReturn(func(ctx context.Context,
-				input *s3manager.UploadInput, opts ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
-				// Read from the input.Body (which is a PipeReader) to simulate actual upload
-				_, readErr := io.ReadAll(input.Body)
-				if readErr != nil {
-					return nil, readErr
-				}
-				return &s3manager.UploadOutput{}, nil
-			})
-		return u
-	}
-	s3Mock := &mocks.S3API{}
-	s3Mock.On("HeadObject", mock.AnythingOfType("*s3.HeadObjectInput")).
-		Return(&s3.HeadObjectOutput{}, awserr.New(s3.ErrCodeNoSuchKey, "key doesn't exist", nil))
+	s3Mock := &mocks.Client{}
+	s3Mock.On("HeadObject", matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
+		Return(&s3.HeadObjectOutput{}, &types.NoSuchKey{})
+	s3Mock.On("PutObject", matchContext, mock.AnythingOfType("*s3.PutObjectInput"), mock.Anything, mock.Anything).
+		Return(&s3.PutObjectOutput{}, nil)
 	file := &File{
 		fileSystem: &FileSystem{
 			client:  s3Mock,
@@ -781,42 +749,36 @@ func (ts *fileTestSuite) TestCloseWithWrite() {
 
 type fileTestCase struct {
 	name             string
-	setup            func(*mocks.S3API) *File // Function to set up each test case
-	actions          []func(*File) error      // Actions to perform on the file (Write, Seek, etc.)
+	setup            func(*mocks.Client) *File // Function to set up each test case
+	actions          []func(*File) error       // Actions to perform on the file (Write, Seek, etc.)
 	wantErr          bool
 	validate         func(*File) error // Additional validations if needed
 	expectedContents string
 }
 
 func (ts *fileTestSuite) TestWriteOperations() {
-	// setup fake uploader
-	oldfunc := getUploader
-	defer func() { getUploader = oldfunc }()
 	var contents *string
-	getUploader = func(client s3iface.S3API, opts ...func(d *s3manager.Uploader)) s3manageriface.UploaderAPI {
-		u := mocks.NewUploaderAPI(ts.T())
-		u.EXPECT().
-			UploadWithContext(mock.Anything, mock.AnythingOfType("*s3manager.UploadInput"), mock.Anything).
-			RunAndReturn(func(ctx context.Context,
-				input *s3manager.UploadInput, opts ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
+	setup := func(s3Mock *mocks.Client) {
+		s3Mock.On("PutObject", matchContext, mock.AnythingOfType("*s3.PutObjectInput"), mock.Anything, mock.Anything).
+			Run(func(args mock.Arguments) {
+				input := args.Get(1).(*s3.PutObjectInput)
 				// Read from the input.Body (which is a PipeReader) to simulate actual upload
 				b, readErr := io.ReadAll(input.Body)
 				if readErr != nil {
-					return nil, readErr
+					panic(readErr)
 				}
 				contents = ptr(string(b))
-				return &s3manager.UploadOutput{}, nil
-			})
-		return u
+			}).
+			Return(&s3.PutObjectOutput{}, nil)
 	}
 
 	testCases := []fileTestCase{
 		{
 			name: "Write and Close - Close failure",
-			setup: func(s3Mock *mocks.S3API) *File {
+			setup: func(s3Mock *mocks.Client) *File {
 				// Mock setup specific to this test case
-				s3Mock.EXPECT().HeadObject(mock.AnythingOfType("*s3.HeadObjectInput")).
-					Return(&s3.HeadObjectOutput{}, awserr.New(s3.ErrCodeNoSuchKey, "", nil)).Times(5)
+				s3Mock.EXPECT().HeadObject(matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
+					Return(&s3.HeadObjectOutput{}, &types.NoSuchKey{}).Times(5)
 				// Return a new File instance with this specific mock configuration
 				return &File{
 					fileSystem: &FileSystem{
@@ -840,9 +802,9 @@ func (ts *fileTestSuite) TestWriteOperations() {
 		},
 		{
 			name: "Write and Close - success",
-			setup: func(s3Mock *mocks.S3API) *File {
+			setup: func(s3Mock *mocks.Client) *File {
 				// Mock setup specific to this test case
-				s3Mock.EXPECT().HeadObject(mock.AnythingOfType("*s3.HeadObjectInput")).
+				s3Mock.EXPECT().HeadObject(matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 					Return(&s3.HeadObjectOutput{}, nil).Once()
 				// Return a new File instance with this specific mock configuration
 				return &File{
@@ -868,11 +830,11 @@ func (ts *fileTestSuite) TestWriteOperations() {
 		},
 		{
 			name: "Write, Seek, Write and Close new file - success",
-			setup: func(s3Mock *mocks.S3API) *File {
+			setup: func(s3Mock *mocks.Client) *File {
 				// Mock setup specific to this test case
-				s3Mock.EXPECT().HeadObject(mock.AnythingOfType("*s3.HeadObjectInput")).
-					Return(nil, awserr.New(s3.ErrCodeNoSuchKey, "", nil)).Twice()
-				s3Mock.EXPECT().HeadObject(mock.AnythingOfType("*s3.HeadObjectInput")).
+				s3Mock.EXPECT().HeadObject(matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
+					Return(nil, &types.NoSuchKey{}).Twice()
+				s3Mock.EXPECT().HeadObject(matchContext, mock.AnythingOfType("*s3.HeadObjectInput")).
 					Return(&s3.HeadObjectOutput{}, nil).Once()
 
 				// Return a new File instance with this specific mock configuration
@@ -916,7 +878,8 @@ func (ts *fileTestSuite) TestWriteOperations() {
 		ts.Run(tc.name, func() {
 			contents = nil // reset contents
 
-			s3Mock := &mocks.S3API{} // Create a new mock for each test
+			s3Mock := &mocks.Client{} // Create a new mock for each test
+			setup(s3Mock)
 			file := tc.setup(s3Mock) // Set up the file for this test
 
 			var err error
diff --git a/backend/s3/location.go b/backend/s3/location.go
index cbec6f19..d3f3df8b 100644
--- a/backend/s3/location.go
+++ b/backend/s3/location.go
@@ -1,13 +1,15 @@
 package s3
 
 import (
+	"context"
 	"errors"
 	"path"
 	"regexp"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
 
 	"github.com/c2fo/vfs/v6"
 	"github.com/c2fo/vfs/v6/options"
@@ -26,7 +28,8 @@ type Location struct {
 // If you have many thousands of keys at the given location, this could become quite expensive.
 func (l *Location) List() ([]string, error) {
 	prefix := utils.RemoveLeadingSlash(l.prefix)
-	listObjectsInput := l.getListObjectsInput().SetPrefix(utils.EnsureTrailingSlash(prefix))
+	listObjectsInput := l.getListObjectsInput()
+	listObjectsInput.Prefix = aws.String(utils.EnsureTrailingSlash(prefix))
 	return l.fullLocationList(listObjectsInput, prefix)
 }
 
@@ -35,7 +38,8 @@ func (l *Location) List() ([]string, error) {
 func (l *Location) ListByPrefix(prefix string) ([]string, error) {
 	searchPrefix := utils.RemoveLeadingSlash(path.Join(l.prefix, prefix))
 	d := path.Dir(searchPrefix)
-	listObjectsInput := l.getListObjectsInput().SetPrefix(searchPrefix)
+	listObjectsInput := l.getListObjectsInput()
+	listObjectsInput.Prefix = aws.String(searchPrefix)
 	return l.fullLocationList(listObjectsInput, d)
 }
 
@@ -70,14 +74,15 @@ func (l *Location) Path() string {
 // permissions. Will receive false without an error if the bucket simply doesn't exist. Otherwise could receive
 // false and any errors passed back from the API.
 func (l *Location) Exists() (bool, error) {
-	headBucketInput := new(s3.HeadBucketInput).SetBucket(l.bucket)
+	headBucketInput := &s3.HeadBucketInput{Bucket: aws.String(l.bucket)}
 	client, err := l.fileSystem.Client()
 	if err != nil {
 		return false, err
 	}
-	_, err = client.HeadBucket(headBucketInput)
+	_, err = client.HeadBucket(context.Background(), headBucketInput)
 	if err != nil {
-		if err.(awserr.Error).Code() == s3.ErrCodeNoSuchBucket {
+		var terr *types.NoSuchBucket
+		if errors.As(err, &terr) {
 			return false, nil
 		}
 		return false, err
@@ -179,7 +184,7 @@ func (l *Location) fullLocationList(input *s3.ListObjectsInput, prefix string) (
 		return keys, err
 	}
 	for {
-		listObjectsOutput, err := client.ListObjects(input)
+		listObjectsOutput, err := client.ListObjects(context.Background(), input)
 		if err != nil {
 			return []string{}, err
 		}
@@ -189,7 +194,7 @@ func (l *Location) fullLocationList(input *s3.ListObjectsInput, prefix string) (
 		// if s3 response "IsTruncated" we need to call List again with
 		// an updated Marker (s3 version of paging)
 		if *listObjectsOutput.IsTruncated {
-			input.SetMarker(*listObjectsOutput.NextMarker)
+			input.Marker = listObjectsOutput.NextMarker
 		} else {
 			break
 		}
@@ -199,10 +204,13 @@ func (l *Location) fullLocationList(input *s3.ListObjectsInput, prefix string) (
 }
 
 func (l *Location) getListObjectsInput() *s3.ListObjectsInput {
-	return new(s3.ListObjectsInput).SetBucket(l.bucket).SetDelimiter("/")
+	return &s3.ListObjectsInput{
+		Bucket:    aws.String(l.bucket),
+		Delimiter: aws.String("/"),
+	}
 }
 
-func getNamesFromObjectSlice(objects []*s3.Object, locationPrefix string) []string {
+func getNamesFromObjectSlice(objects []types.Object, locationPrefix string) []string {
 	var keys []string
 	for _, object := range objects {
 		if *object.Key != locationPrefix {
diff --git a/backend/s3/location_test.go b/backend/s3/location_test.go
index 9d026109..9b44c6fc 100644
--- a/backend/s3/location_test.go
+++ b/backend/s3/location_test.go
@@ -5,8 +5,9 @@ import (
 	"regexp"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 
@@ -18,12 +19,12 @@ import (
 type locationTestSuite struct {
 	suite.Suite
 	fs        *FileSystem
-	s3apiMock *mocks.S3API
+	s3cliMock *mocks.Client
 }
 
 func (lt *locationTestSuite) SetupTest() {
-	lt.s3apiMock = &mocks.S3API{}
-	lt.fs = &FileSystem{client: lt.s3apiMock}
+	lt.s3cliMock = &mocks.Client{}
+	lt.fs = &FileSystem{client: lt.s3cliMock}
 }
 
 func (lt *locationTestSuite) TestList() {
@@ -34,7 +35,7 @@ func (lt *locationTestSuite) TestList() {
 	prefix := "dir1/"
 	delimiter := "/"
 	isTruncated := false
-	lt.s3apiMock.On("ListObjects", &s3.ListObjectsInput{
+	lt.s3cliMock.On("ListObjects", matchContext, &s3.ListObjectsInput{
 		Bucket:    &bucket,
 		Prefix:    &prefix,
 		Delimiter: &delimiter,
@@ -52,7 +53,7 @@ func (lt *locationTestSuite) TestList() {
 	for _, fileKey := range fileList {
 		lt.Contains(expectedFileList, fileKey, "All returned keys should be in expected file list.")
 	}
-	lt.s3apiMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertExpectations(lt.T())
 }
 
 func (lt *locationTestSuite) TestList_pagedCall() {
@@ -66,7 +67,7 @@ func (lt *locationTestSuite) TestList_pagedCall() {
 	delimiter := "/"
 	isTruncatedTrue := true
 	isTruncatedFalse := false
-	lt.s3apiMock.On("ListObjects", &s3.ListObjectsInput{
+	lt.s3cliMock.On("ListObjects", matchContext, &s3.ListObjectsInput{
 		Bucket:    &bucket,
 		Prefix:    &prefix,
 		Delimiter: &delimiter,
@@ -77,7 +78,7 @@ func (lt *locationTestSuite) TestList_pagedCall() {
 		Prefix:      &prefix,
 	}, nil)
 
-	lt.s3apiMock.On("ListObjects", &s3.ListObjectsInput{
+	lt.s3cliMock.On("ListObjects", matchContext, &s3.ListObjectsInput{
 		Bucket:    &bucket,
 		Prefix:    &prefix,
 		Delimiter: &delimiter,
@@ -96,7 +97,7 @@ func (lt *locationTestSuite) TestList_pagedCall() {
 	for _, expectedKey := range expectedFileList {
 		lt.Contains(fileList, expectedKey, "All returned keys should be in expected file list.")
 	}
-	lt.s3apiMock.AssertNumberOfCalls(lt.T(), "ListObjects", 2)
+	lt.s3cliMock.AssertNumberOfCalls(lt.T(), "ListObjects", 2)
 }
 
 func (lt *locationTestSuite) TestListByPrefix() {
@@ -108,7 +109,7 @@ func (lt *locationTestSuite) TestListByPrefix() {
 	apiCallPrefix := utils.RemoveLeadingSlash(path.Join(locPath, prefix))
 	delimiter := "/"
 	isTruncated := false
-	lt.s3apiMock.On("ListObjects", &s3.ListObjectsInput{
+	lt.s3cliMock.On("ListObjects", matchContext, &s3.ListObjectsInput{
 		Bucket:    &bucket,
 		Prefix:    &apiCallPrefix,
 		Delimiter: &delimiter,
@@ -125,7 +126,7 @@ func (lt *locationTestSuite) TestListByPrefix() {
 	for _, fileKey := range fileList {
 		lt.Contains(expectedFileList, fileKey, "All returned keys should be in the expected list.")
 	}
-	lt.s3apiMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertExpectations(lt.T())
 }
 
 func (lt *locationTestSuite) TestListByRegex() {
@@ -136,7 +137,7 @@ func (lt *locationTestSuite) TestListByRegex() {
 	prefix := "blah/"
 	delimiter := "/"
 	isTruncated := false
-	lt.s3apiMock.On("ListObjects", &s3.ListObjectsInput{
+	lt.s3cliMock.On("ListObjects", matchContext, &s3.ListObjectsInput{
 		Bucket:    &bucket,
 		Prefix:    &prefix,
 		Delimiter: &delimiter,
@@ -155,7 +156,7 @@ func (lt *locationTestSuite) TestListByRegex() {
 	for _, fileKey := range fileList {
 		lt.Contains(expectedFileList, fileKey, "All returned keys should be in the expected list.")
 	}
-	lt.s3apiMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertExpectations(lt.T())
 }
 
 func (lt *locationTestSuite) TestVolume() {
@@ -206,7 +207,7 @@ func (lt *locationTestSuite) TestNewFile() {
 
 func (lt *locationTestSuite) TestExists_true() {
 	bucket := "foo"
-	lt.s3apiMock.On("HeadBucket", &s3.HeadBucketInput{
+	lt.s3cliMock.On("HeadBucket", matchContext, &s3.HeadBucketInput{
 		Bucket: &bucket,
 	}).Return(&s3.HeadBucketOutput{}, nil).Once()
 	loc, err := lt.fs.NewLocation(bucket, "/")
@@ -214,20 +215,20 @@ func (lt *locationTestSuite) TestExists_true() {
 	exists, err := loc.Exists()
 	lt.NoError(err, "No error expected from Exists")
 	lt.True(exists, "Call to Exists expected to return true.")
-	lt.s3apiMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertExpectations(lt.T())
 }
 
 func (lt *locationTestSuite) TestExists_false() {
 	bucket := "foo"
-	lt.s3apiMock.On("HeadBucket", &s3.HeadBucketInput{
+	lt.s3cliMock.On("HeadBucket", matchContext, &s3.HeadBucketInput{
 		Bucket: &bucket,
-	}).Return(nil, awserr.New(s3.ErrCodeNoSuchBucket, "NoSuchBucket", nil)).Once()
+	}).Return(nil, &types.NoSuchBucket{}).Once()
 	loc, err := lt.fs.NewLocation(bucket, "/")
 	lt.NoError(err)
 	exists, err := loc.Exists()
 	lt.NoError(err, "No error expected from Exists")
 	lt.False(exists, "Call to Exists expected to return true.")
-	lt.s3apiMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertExpectations(lt.T())
 }
 
 func (lt *locationTestSuite) TestChangeDir() {
@@ -291,33 +292,33 @@ func (lt *locationTestSuite) TestStringURI() {
 }
 
 func (lt *locationTestSuite) TestDeleteFile() {
-	lt.s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	lt.s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 	loc, err := lt.fs.NewLocation("bucket", "/old/")
 	lt.NoError(err)
 
 	err = loc.DeleteFile("filename.txt")
 	lt.NoError(err, "Successful delete should not return an error.")
-	lt.s3apiMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertExpectations(lt.T())
 }
 
 func (lt *locationTestSuite) TestDeleteFileWithAllVersionsOption() {
-	var versions []*s3.ObjectVersion
+	var versions []types.ObjectVersion
 	verIds := [...]string{"ver1", "ver2"}
 	for i := range verIds {
-		versions = append(versions, &s3.ObjectVersion{VersionId: &verIds[i]})
+		versions = append(versions, types.ObjectVersion{VersionId: &verIds[i]})
 	}
 	versOutput := s3.ListObjectVersionsOutput{
 		Versions: versions,
 	}
-	lt.s3apiMock.On("ListObjectVersions", mock.AnythingOfType("*s3.ListObjectVersionsInput")).Return(&versOutput, nil)
-	lt.s3apiMock.On("DeleteObject", mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
+	lt.s3cliMock.On("ListObjectVersions", matchContext, mock.AnythingOfType("*s3.ListObjectVersionsInput")).Return(&versOutput, nil)
+	lt.s3cliMock.On("DeleteObject", matchContext, mock.AnythingOfType("*s3.DeleteObjectInput")).Return(&s3.DeleteObjectOutput{}, nil)
 	loc, err := lt.fs.NewLocation("bucket", "/old/")
 	lt.NoError(err)
 
 	err = loc.DeleteFile("filename.txt", delete.WithAllVersions())
 	lt.NoError(err, "Successful delete should not return an error.")
-	lt.s3apiMock.AssertExpectations(lt.T())
-	lt.s3apiMock.AssertNumberOfCalls(lt.T(), "DeleteObject", 3)
+	lt.s3cliMock.AssertExpectations(lt.T())
+	lt.s3cliMock.AssertNumberOfCalls(lt.T(), "DeleteObject", 3)
 }
 
 func TestLocation(t *testing.T) {
@@ -327,11 +328,11 @@ func TestLocation(t *testing.T) {
 /*
 Helpers
 */
-func convertKeysToS3Objects(keys []string) []*s3.Object {
-	var objects []*s3.Object
+func convertKeysToS3Objects(keys []string) []types.Object {
+	var objects []types.Object
 	for _, key := range keys {
-		object := &s3.Object{}
-		objects = append(objects, object.SetKey(key))
+		object := types.Object{Key: aws.String(key)}
+		objects = append(objects, object)
 	}
 	return objects
 }
diff --git a/backend/s3/mocks/Client.go b/backend/s3/mocks/Client.go
new file mode 100644
index 00000000..00c3ad7f
--- /dev/null
+++ b/backend/s3/mocks/Client.go
@@ -0,0 +1,925 @@
+// Code generated by mockery v2.46.3. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	s3 "github.com/aws/aws-sdk-go-v2/service/s3"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// Client is an autogenerated mock type for the Client type
+type Client struct {
+	mock.Mock
+}
+
+type Client_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Client) EXPECT() *Client_Expecter {
+	return &Client_Expecter{mock: &_m.Mock}
+}
+
+// AbortMultipartUpload provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Client) AbortMultipartUpload(_a0 context.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error) {
+	_va := make([]interface{}, len(_a2))
+	for _i := range _a2 {
+		_va[_i] = _a2[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0, _a1)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AbortMultipartUpload")
+	}
+
+	var r0 *s3.AbortMultipartUploadOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)); ok {
+		return rf(_a0, _a1, _a2...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) *s3.AbortMultipartUploadOutput); ok {
+		r0 = rf(_a0, _a1, _a2...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.AbortMultipartUploadOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(_a0, _a1, _a2...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_AbortMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUpload'
+type Client_AbortMultipartUpload_Call struct {
+	*mock.Call
+}
+
+// AbortMultipartUpload is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *s3.AbortMultipartUploadInput
+//   - _a2 ...func(*s3.Options)
+func (_e *Client_Expecter) AbortMultipartUpload(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_AbortMultipartUpload_Call {
+	return &Client_AbortMultipartUpload_Call{Call: _e.mock.On("AbortMultipartUpload",
+		append([]interface{}{_a0, _a1}, _a2...)...)}
+}
+
+func (_c *Client_AbortMultipartUpload_Call) Run(run func(_a0 context.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...func(*s3.Options))) *Client_AbortMultipartUpload_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.AbortMultipartUploadInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_AbortMultipartUpload_Call) Return(_a0 *s3.AbortMultipartUploadOutput, _a1 error) *Client_AbortMultipartUpload_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_AbortMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)) *Client_AbortMultipartUpload_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CompleteMultipartUpload provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Client) CompleteMultipartUpload(_a0 context.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error) {
+	_va := make([]interface{}, len(_a2))
+	for _i := range _a2 {
+		_va[_i] = _a2[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0, _a1)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CompleteMultipartUpload")
+	}
+
+	var r0 *s3.CompleteMultipartUploadOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)); ok {
+		return rf(_a0, _a1, _a2...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) *s3.CompleteMultipartUploadOutput); ok {
+		r0 = rf(_a0, _a1, _a2...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.CompleteMultipartUploadOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(_a0, _a1, _a2...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_CompleteMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUpload'
+type Client_CompleteMultipartUpload_Call struct {
+	*mock.Call
+}
+
+// CompleteMultipartUpload is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *s3.CompleteMultipartUploadInput
+//   - _a2 ...func(*s3.Options)
+func (_e *Client_Expecter) CompleteMultipartUpload(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_CompleteMultipartUpload_Call {
+	return &Client_CompleteMultipartUpload_Call{Call: _e.mock.On("CompleteMultipartUpload",
+		append([]interface{}{_a0, _a1}, _a2...)...)}
+}
+
+func (_c *Client_CompleteMultipartUpload_Call) Run(run func(_a0 context.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...func(*s3.Options))) *Client_CompleteMultipartUpload_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.CompleteMultipartUploadInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_CompleteMultipartUpload_Call) Return(_a0 *s3.CompleteMultipartUploadOutput, _a1 error) *Client_CompleteMultipartUpload_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_CompleteMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)) *Client_CompleteMultipartUpload_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CopyObject provides a mock function with given fields: ctx, params, optFns
+func (_m *Client) CopyObject(ctx context.Context, params *s3.CopyObjectInput, optFns ...func(*s3.Options)) (*s3.CopyObjectOutput, error) {
+	_va := make([]interface{}, len(optFns))
+	for _i := range optFns {
+		_va[_i] = optFns[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, params)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CopyObject")
+	}
+
+	var r0 *s3.CopyObjectOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) (*s3.CopyObjectOutput, error)); ok {
+		return rf(ctx, params, optFns...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) *s3.CopyObjectOutput); ok {
+		r0 = rf(ctx, params, optFns...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.CopyObjectOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(ctx, params, optFns...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_CopyObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObject'
+type Client_CopyObject_Call struct {
+	*mock.Call
+}
+
+// CopyObject is a helper method to define mock.On call
+//   - ctx context.Context
+//   - params *s3.CopyObjectInput
+//   - optFns ...func(*s3.Options)
+func (_e *Client_Expecter) CopyObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CopyObject_Call {
+	return &Client_CopyObject_Call{Call: _e.mock.On("CopyObject",
+		append([]interface{}{ctx, params}, optFns...)...)}
+}
+
+func (_c *Client_CopyObject_Call) Run(run func(ctx context.Context, params *s3.CopyObjectInput, optFns ...func(*s3.Options))) *Client_CopyObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.CopyObjectInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_CopyObject_Call) Return(_a0 *s3.CopyObjectOutput, _a1 error) *Client_CopyObject_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_CopyObject_Call) RunAndReturn(run func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) (*s3.CopyObjectOutput, error)) *Client_CopyObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateMultipartUpload provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Client) CreateMultipartUpload(_a0 context.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error) {
+	_va := make([]interface{}, len(_a2))
+	for _i := range _a2 {
+		_va[_i] = _a2[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0, _a1)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateMultipartUpload")
+	}
+
+	var r0 *s3.CreateMultipartUploadOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)); ok {
+		return rf(_a0, _a1, _a2...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) *s3.CreateMultipartUploadOutput); ok {
+		r0 = rf(_a0, _a1, _a2...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.CreateMultipartUploadOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(_a0, _a1, _a2...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_CreateMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUpload'
+type Client_CreateMultipartUpload_Call struct {
+	*mock.Call
+}
+
+// CreateMultipartUpload is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *s3.CreateMultipartUploadInput
+//   - _a2 ...func(*s3.Options)
+func (_e *Client_Expecter) CreateMultipartUpload(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_CreateMultipartUpload_Call {
+	return &Client_CreateMultipartUpload_Call{Call: _e.mock.On("CreateMultipartUpload",
+		append([]interface{}{_a0, _a1}, _a2...)...)}
+}
+
+func (_c *Client_CreateMultipartUpload_Call) Run(run func(_a0 context.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...func(*s3.Options))) *Client_CreateMultipartUpload_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.CreateMultipartUploadInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_CreateMultipartUpload_Call) Return(_a0 *s3.CreateMultipartUploadOutput, _a1 error) *Client_CreateMultipartUpload_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_CreateMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)) *Client_CreateMultipartUpload_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteObject provides a mock function with given fields: ctx, params, optFns
+func (_m *Client) DeleteObject(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectOutput, error) {
+	_va := make([]interface{}, len(optFns))
+	for _i := range optFns {
+		_va[_i] = optFns[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, params)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteObject")
+	}
+
+	var r0 *s3.DeleteObjectOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)); ok {
+		return rf(ctx, params, optFns...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) *s3.DeleteObjectOutput); ok {
+		r0 = rf(ctx, params, optFns...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.DeleteObjectOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(ctx, params, optFns...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_DeleteObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObject'
+type Client_DeleteObject_Call struct {
+	*mock.Call
+}
+
+// DeleteObject is a helper method to define mock.On call
+//   - ctx context.Context
+//   - params *s3.DeleteObjectInput
+//   - optFns ...func(*s3.Options)
+func (_e *Client_Expecter) DeleteObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteObject_Call {
+	return &Client_DeleteObject_Call{Call: _e.mock.On("DeleteObject",
+		append([]interface{}{ctx, params}, optFns...)...)}
+}
+
+func (_c *Client_DeleteObject_Call) Run(run func(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options))) *Client_DeleteObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.DeleteObjectInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_DeleteObject_Call) Return(_a0 *s3.DeleteObjectOutput, _a1 error) *Client_DeleteObject_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_DeleteObject_Call) RunAndReturn(run func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)) *Client_DeleteObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetObject provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Client) GetObject(_a0 context.Context, _a1 *s3.GetObjectInput, _a2 ...func(*s3.Options)) (*s3.GetObjectOutput, error) {
+	_va := make([]interface{}, len(_a2))
+	for _i := range _a2 {
+		_va[_i] = _a2[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0, _a1)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetObject")
+	}
+
+	var r0 *s3.GetObjectOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)); ok {
+		return rf(_a0, _a1, _a2...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) *s3.GetObjectOutput); ok {
+		r0 = rf(_a0, _a1, _a2...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.GetObjectOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(_a0, _a1, _a2...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_GetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObject'
+type Client_GetObject_Call struct {
+	*mock.Call
+}
+
+// GetObject is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *s3.GetObjectInput
+//   - _a2 ...func(*s3.Options)
+func (_e *Client_Expecter) GetObject(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_GetObject_Call {
+	return &Client_GetObject_Call{Call: _e.mock.On("GetObject",
+		append([]interface{}{_a0, _a1}, _a2...)...)}
+}
+
+func (_c *Client_GetObject_Call) Run(run func(_a0 context.Context, _a1 *s3.GetObjectInput, _a2 ...func(*s3.Options))) *Client_GetObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.GetObjectInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_GetObject_Call) Return(_a0 *s3.GetObjectOutput, _a1 error) *Client_GetObject_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_GetObject_Call) RunAndReturn(run func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)) *Client_GetObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// HeadBucket provides a mock function with given fields: ctx, params, optFns
+func (_m *Client) HeadBucket(ctx context.Context, params *s3.HeadBucketInput, optFns ...func(*s3.Options)) (*s3.HeadBucketOutput, error) {
+	_va := make([]interface{}, len(optFns))
+	for _i := range optFns {
+		_va[_i] = optFns[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, params)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HeadBucket")
+	}
+
+	var r0 *s3.HeadBucketOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) (*s3.HeadBucketOutput, error)); ok {
+		return rf(ctx, params, optFns...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) *s3.HeadBucketOutput); ok {
+		r0 = rf(ctx, params, optFns...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.HeadBucketOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(ctx, params, optFns...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_HeadBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucket'
+type Client_HeadBucket_Call struct {
+	*mock.Call
+}
+
+// HeadBucket is a helper method to define mock.On call
+//   - ctx context.Context
+//   - params *s3.HeadBucketInput
+//   - optFns ...func(*s3.Options)
+func (_e *Client_Expecter) HeadBucket(ctx interface{}, params interface{}, optFns ...interface{}) *Client_HeadBucket_Call {
+	return &Client_HeadBucket_Call{Call: _e.mock.On("HeadBucket",
+		append([]interface{}{ctx, params}, optFns...)...)}
+}
+
+func (_c *Client_HeadBucket_Call) Run(run func(ctx context.Context, params *s3.HeadBucketInput, optFns ...func(*s3.Options))) *Client_HeadBucket_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.HeadBucketInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_HeadBucket_Call) Return(_a0 *s3.HeadBucketOutput, _a1 error) *Client_HeadBucket_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_HeadBucket_Call) RunAndReturn(run func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) (*s3.HeadBucketOutput, error)) *Client_HeadBucket_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// HeadObject provides a mock function with given fields: ctx, params, optFns
+func (_m *Client) HeadObject(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options)) (*s3.HeadObjectOutput, error) {
+	_va := make([]interface{}, len(optFns))
+	for _i := range optFns {
+		_va[_i] = optFns[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, params)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HeadObject")
+	}
+
+	var r0 *s3.HeadObjectOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) (*s3.HeadObjectOutput, error)); ok {
+		return rf(ctx, params, optFns...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) *s3.HeadObjectOutput); ok {
+		r0 = rf(ctx, params, optFns...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.HeadObjectOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(ctx, params, optFns...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_HeadObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObject'
+type Client_HeadObject_Call struct {
+	*mock.Call
+}
+
+// HeadObject is a helper method to define mock.On call
+//   - ctx context.Context
+//   - params *s3.HeadObjectInput
+//   - optFns ...func(*s3.Options)
+func (_e *Client_Expecter) HeadObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_HeadObject_Call {
+	return &Client_HeadObject_Call{Call: _e.mock.On("HeadObject",
+		append([]interface{}{ctx, params}, optFns...)...)}
+}
+
+func (_c *Client_HeadObject_Call) Run(run func(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options))) *Client_HeadObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.HeadObjectInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_HeadObject_Call) Return(_a0 *s3.HeadObjectOutput, _a1 error) *Client_HeadObject_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_HeadObject_Call) RunAndReturn(run func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) (*s3.HeadObjectOutput, error)) *Client_HeadObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListObjectVersions provides a mock function with given fields: ctx, params, optFns
+func (_m *Client) ListObjectVersions(ctx context.Context, params *s3.ListObjectVersionsInput, optFns ...func(*s3.Options)) (*s3.ListObjectVersionsOutput, error) {
+	_va := make([]interface{}, len(optFns))
+	for _i := range optFns {
+		_va[_i] = optFns[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, params)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListObjectVersions")
+	}
+
+	var r0 *s3.ListObjectVersionsOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectVersionsInput, ...func(*s3.Options)) (*s3.ListObjectVersionsOutput, error)); ok {
+		return rf(ctx, params, optFns...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectVersionsInput, ...func(*s3.Options)) *s3.ListObjectVersionsOutput); ok {
+		r0 = rf(ctx, params, optFns...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.ListObjectVersionsOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectVersionsInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(ctx, params, optFns...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_ListObjectVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersions'
+type Client_ListObjectVersions_Call struct {
+	*mock.Call
+}
+
+// ListObjectVersions is a helper method to define mock.On call
+//   - ctx context.Context
+//   - params *s3.ListObjectVersionsInput
+//   - optFns ...func(*s3.Options)
+func (_e *Client_Expecter) ListObjectVersions(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListObjectVersions_Call {
+	return &Client_ListObjectVersions_Call{Call: _e.mock.On("ListObjectVersions",
+		append([]interface{}{ctx, params}, optFns...)...)}
+}
+
+func (_c *Client_ListObjectVersions_Call) Run(run func(ctx context.Context, params *s3.ListObjectVersionsInput, optFns ...func(*s3.Options))) *Client_ListObjectVersions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.ListObjectVersionsInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_ListObjectVersions_Call) Return(_a0 *s3.ListObjectVersionsOutput, _a1 error) *Client_ListObjectVersions_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_ListObjectVersions_Call) RunAndReturn(run func(context.Context, *s3.ListObjectVersionsInput, ...func(*s3.Options)) (*s3.ListObjectVersionsOutput, error)) *Client_ListObjectVersions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListObjects provides a mock function with given fields: ctx, params, optFns
+func (_m *Client) ListObjects(ctx context.Context, params *s3.ListObjectsInput, optFns ...func(*s3.Options)) (*s3.ListObjectsOutput, error) {
+	_va := make([]interface{}, len(optFns))
+	for _i := range optFns {
+		_va[_i] = optFns[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, params)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListObjects")
+	}
+
+	var r0 *s3.ListObjectsOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) (*s3.ListObjectsOutput, error)); ok {
+		return rf(ctx, params, optFns...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) *s3.ListObjectsOutput); ok {
+		r0 = rf(ctx, params, optFns...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.ListObjectsOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(ctx, params, optFns...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_ListObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjects'
+type Client_ListObjects_Call struct {
+	*mock.Call
+}
+
+// ListObjects is a helper method to define mock.On call
+//   - ctx context.Context
+//   - params *s3.ListObjectsInput
+//   - optFns ...func(*s3.Options)
+func (_e *Client_Expecter) ListObjects(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListObjects_Call {
+	return &Client_ListObjects_Call{Call: _e.mock.On("ListObjects",
+		append([]interface{}{ctx, params}, optFns...)...)}
+}
+
+func (_c *Client_ListObjects_Call) Run(run func(ctx context.Context, params *s3.ListObjectsInput, optFns ...func(*s3.Options))) *Client_ListObjects_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.ListObjectsInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_ListObjects_Call) Return(_a0 *s3.ListObjectsOutput, _a1 error) *Client_ListObjects_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_ListObjects_Call) RunAndReturn(run func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) (*s3.ListObjectsOutput, error)) *Client_ListObjects_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PutObject provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Client) PutObject(_a0 context.Context, _a1 *s3.PutObjectInput, _a2 ...func(*s3.Options)) (*s3.PutObjectOutput, error) {
+	_va := make([]interface{}, len(_a2))
+	for _i := range _a2 {
+		_va[_i] = _a2[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0, _a1)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PutObject")
+	}
+
+	var r0 *s3.PutObjectOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)); ok {
+		return rf(_a0, _a1, _a2...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) *s3.PutObjectOutput); ok {
+		r0 = rf(_a0, _a1, _a2...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.PutObjectOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(_a0, _a1, _a2...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_PutObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObject'
+type Client_PutObject_Call struct {
+	*mock.Call
+}
+
+// PutObject is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *s3.PutObjectInput
+//   - _a2 ...func(*s3.Options)
+func (_e *Client_Expecter) PutObject(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_PutObject_Call {
+	return &Client_PutObject_Call{Call: _e.mock.On("PutObject",
+		append([]interface{}{_a0, _a1}, _a2...)...)}
+}
+
+func (_c *Client_PutObject_Call) Run(run func(_a0 context.Context, _a1 *s3.PutObjectInput, _a2 ...func(*s3.Options))) *Client_PutObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.PutObjectInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_PutObject_Call) Return(_a0 *s3.PutObjectOutput, _a1 error) *Client_PutObject_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_PutObject_Call) RunAndReturn(run func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)) *Client_PutObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UploadPart provides a mock function with given fields: _a0, _a1, _a2
+func (_m *Client) UploadPart(_a0 context.Context, _a1 *s3.UploadPartInput, _a2 ...func(*s3.Options)) (*s3.UploadPartOutput, error) {
+	_va := make([]interface{}, len(_a2))
+	for _i := range _a2 {
+		_va[_i] = _a2[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _a0, _a1)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UploadPart")
+	}
+
+	var r0 *s3.UploadPartOutput
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)); ok {
+		return rf(_a0, _a1, _a2...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) *s3.UploadPartOutput); ok {
+		r0 = rf(_a0, _a1, _a2...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*s3.UploadPartOutput)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) error); ok {
+		r1 = rf(_a0, _a1, _a2...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Client_UploadPart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPart'
+type Client_UploadPart_Call struct {
+	*mock.Call
+}
+
+// UploadPart is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *s3.UploadPartInput
+//   - _a2 ...func(*s3.Options)
+func (_e *Client_Expecter) UploadPart(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_UploadPart_Call {
+	return &Client_UploadPart_Call{Call: _e.mock.On("UploadPart",
+		append([]interface{}{_a0, _a1}, _a2...)...)}
+}
+
+func (_c *Client_UploadPart_Call) Run(run func(_a0 context.Context, _a1 *s3.UploadPartInput, _a2 ...func(*s3.Options))) *Client_UploadPart_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]func(*s3.Options), len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(func(*s3.Options))
+			}
+		}
+		run(args[0].(context.Context), args[1].(*s3.UploadPartInput), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_UploadPart_Call) Return(_a0 *s3.UploadPartOutput, _a1 error) *Client_UploadPart_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_UploadPart_Call) RunAndReturn(run func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)) *Client_UploadPart_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Client {
+	mock := &Client{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/backend/s3/mocks/S3API.go b/backend/s3/mocks/S3API.go
deleted file mode 100644
index 831e50ab..00000000
--- a/backend/s3/mocks/S3API.go
+++ /dev/null
@@ -1,20139 +0,0 @@
-// Code generated by mockery v2.46.3. DO NOT EDIT.
-
-package mocks
-
-import (
-	aws "github.com/aws/aws-sdk-go/aws"
-	mock "github.com/stretchr/testify/mock"
-
-	request "github.com/aws/aws-sdk-go/aws/request"
-
-	s3 "github.com/aws/aws-sdk-go/service/s3"
-)
-
-// S3API is an autogenerated mock type for the S3API type
-type S3API struct {
-	mock.Mock
-}
-
-type S3API_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *S3API) EXPECT() *S3API_Expecter {
-	return &S3API_Expecter{mock: &_m.Mock}
-}
-
-// AbortMultipartUpload provides a mock function with given fields: _a0
-func (_m *S3API) AbortMultipartUpload(_a0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AbortMultipartUpload")
-	}
-
-	var r0 *s3.AbortMultipartUploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) *s3.AbortMultipartUploadOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.AbortMultipartUploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.AbortMultipartUploadInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_AbortMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUpload'
-type S3API_AbortMultipartUpload_Call struct {
-	*mock.Call
-}
-
-// AbortMultipartUpload is a helper method to define mock.On call
-//   - _a0 *s3.AbortMultipartUploadInput
-func (_e *S3API_Expecter) AbortMultipartUpload(_a0 interface{}) *S3API_AbortMultipartUpload_Call {
-	return &S3API_AbortMultipartUpload_Call{Call: _e.mock.On("AbortMultipartUpload", _a0)}
-}
-
-func (_c *S3API_AbortMultipartUpload_Call) Run(run func(_a0 *s3.AbortMultipartUploadInput)) *S3API_AbortMultipartUpload_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.AbortMultipartUploadInput))
-	})
-	return _c
-}
-
-func (_c *S3API_AbortMultipartUpload_Call) Return(_a0 *s3.AbortMultipartUploadOutput, _a1 error) *S3API_AbortMultipartUpload_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_AbortMultipartUpload_Call) RunAndReturn(run func(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)) *S3API_AbortMultipartUpload_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// AbortMultipartUploadRequest provides a mock function with given fields: _a0
-func (_m *S3API) AbortMultipartUploadRequest(_a0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AbortMultipartUploadRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.AbortMultipartUploadOutput
-	if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.AbortMultipartUploadInput) *s3.AbortMultipartUploadOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.AbortMultipartUploadOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_AbortMultipartUploadRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUploadRequest'
-type S3API_AbortMultipartUploadRequest_Call struct {
-	*mock.Call
-}
-
-// AbortMultipartUploadRequest is a helper method to define mock.On call
-//   - _a0 *s3.AbortMultipartUploadInput
-func (_e *S3API_Expecter) AbortMultipartUploadRequest(_a0 interface{}) *S3API_AbortMultipartUploadRequest_Call {
-	return &S3API_AbortMultipartUploadRequest_Call{Call: _e.mock.On("AbortMultipartUploadRequest", _a0)}
-}
-
-func (_c *S3API_AbortMultipartUploadRequest_Call) Run(run func(_a0 *s3.AbortMultipartUploadInput)) *S3API_AbortMultipartUploadRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.AbortMultipartUploadInput))
-	})
-	return _c
-}
-
-func (_c *S3API_AbortMultipartUploadRequest_Call) Return(_a0 *request.Request, _a1 *s3.AbortMultipartUploadOutput) *S3API_AbortMultipartUploadRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_AbortMultipartUploadRequest_Call) RunAndReturn(run func(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)) *S3API_AbortMultipartUploadRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// AbortMultipartUploadWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) AbortMultipartUploadWithContext(_a0 aws.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...request.Option) (*s3.AbortMultipartUploadOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AbortMultipartUploadWithContext")
-	}
-
-	var r0 *s3.AbortMultipartUploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) (*s3.AbortMultipartUploadOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) *s3.AbortMultipartUploadOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.AbortMultipartUploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_AbortMultipartUploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUploadWithContext'
-type S3API_AbortMultipartUploadWithContext_Call struct {
-	*mock.Call
-}
-
-// AbortMultipartUploadWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.AbortMultipartUploadInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) AbortMultipartUploadWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_AbortMultipartUploadWithContext_Call {
-	return &S3API_AbortMultipartUploadWithContext_Call{Call: _e.mock.On("AbortMultipartUploadWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_AbortMultipartUploadWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...request.Option)) *S3API_AbortMultipartUploadWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.AbortMultipartUploadInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_AbortMultipartUploadWithContext_Call) Return(_a0 *s3.AbortMultipartUploadOutput, _a1 error) *S3API_AbortMultipartUploadWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_AbortMultipartUploadWithContext_Call) RunAndReturn(run func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) (*s3.AbortMultipartUploadOutput, error)) *S3API_AbortMultipartUploadWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CompleteMultipartUpload provides a mock function with given fields: _a0
-func (_m *S3API) CompleteMultipartUpload(_a0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CompleteMultipartUpload")
-	}
-
-	var r0 *s3.CompleteMultipartUploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) *s3.CompleteMultipartUploadOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CompleteMultipartUploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CompleteMultipartUploadInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CompleteMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUpload'
-type S3API_CompleteMultipartUpload_Call struct {
-	*mock.Call
-}
-
-// CompleteMultipartUpload is a helper method to define mock.On call
-//   - _a0 *s3.CompleteMultipartUploadInput
-func (_e *S3API_Expecter) CompleteMultipartUpload(_a0 interface{}) *S3API_CompleteMultipartUpload_Call {
-	return &S3API_CompleteMultipartUpload_Call{Call: _e.mock.On("CompleteMultipartUpload", _a0)}
-}
-
-func (_c *S3API_CompleteMultipartUpload_Call) Run(run func(_a0 *s3.CompleteMultipartUploadInput)) *S3API_CompleteMultipartUpload_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CompleteMultipartUploadInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CompleteMultipartUpload_Call) Return(_a0 *s3.CompleteMultipartUploadOutput, _a1 error) *S3API_CompleteMultipartUpload_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CompleteMultipartUpload_Call) RunAndReturn(run func(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)) *S3API_CompleteMultipartUpload_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CompleteMultipartUploadRequest provides a mock function with given fields: _a0
-func (_m *S3API) CompleteMultipartUploadRequest(_a0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CompleteMultipartUploadRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.CompleteMultipartUploadOutput
-	if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CompleteMultipartUploadInput) *s3.CompleteMultipartUploadOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.CompleteMultipartUploadOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_CompleteMultipartUploadRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUploadRequest'
-type S3API_CompleteMultipartUploadRequest_Call struct {
-	*mock.Call
-}
-
-// CompleteMultipartUploadRequest is a helper method to define mock.On call
-//   - _a0 *s3.CompleteMultipartUploadInput
-func (_e *S3API_Expecter) CompleteMultipartUploadRequest(_a0 interface{}) *S3API_CompleteMultipartUploadRequest_Call {
-	return &S3API_CompleteMultipartUploadRequest_Call{Call: _e.mock.On("CompleteMultipartUploadRequest", _a0)}
-}
-
-func (_c *S3API_CompleteMultipartUploadRequest_Call) Run(run func(_a0 *s3.CompleteMultipartUploadInput)) *S3API_CompleteMultipartUploadRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CompleteMultipartUploadInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CompleteMultipartUploadRequest_Call) Return(_a0 *request.Request, _a1 *s3.CompleteMultipartUploadOutput) *S3API_CompleteMultipartUploadRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CompleteMultipartUploadRequest_Call) RunAndReturn(run func(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)) *S3API_CompleteMultipartUploadRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CompleteMultipartUploadWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) CompleteMultipartUploadWithContext(_a0 aws.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...request.Option) (*s3.CompleteMultipartUploadOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CompleteMultipartUploadWithContext")
-	}
-
-	var r0 *s3.CompleteMultipartUploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) (*s3.CompleteMultipartUploadOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) *s3.CompleteMultipartUploadOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CompleteMultipartUploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CompleteMultipartUploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUploadWithContext'
-type S3API_CompleteMultipartUploadWithContext_Call struct {
-	*mock.Call
-}
-
-// CompleteMultipartUploadWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.CompleteMultipartUploadInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) CompleteMultipartUploadWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_CompleteMultipartUploadWithContext_Call {
-	return &S3API_CompleteMultipartUploadWithContext_Call{Call: _e.mock.On("CompleteMultipartUploadWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_CompleteMultipartUploadWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...request.Option)) *S3API_CompleteMultipartUploadWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.CompleteMultipartUploadInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_CompleteMultipartUploadWithContext_Call) Return(_a0 *s3.CompleteMultipartUploadOutput, _a1 error) *S3API_CompleteMultipartUploadWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CompleteMultipartUploadWithContext_Call) RunAndReturn(run func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) (*s3.CompleteMultipartUploadOutput, error)) *S3API_CompleteMultipartUploadWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CopyObject provides a mock function with given fields: _a0
-func (_m *S3API) CopyObject(_a0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CopyObject")
-	}
-
-	var r0 *s3.CopyObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) *s3.CopyObjectOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CopyObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CopyObjectInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CopyObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObject'
-type S3API_CopyObject_Call struct {
-	*mock.Call
-}
-
-// CopyObject is a helper method to define mock.On call
-//   - _a0 *s3.CopyObjectInput
-func (_e *S3API_Expecter) CopyObject(_a0 interface{}) *S3API_CopyObject_Call {
-	return &S3API_CopyObject_Call{Call: _e.mock.On("CopyObject", _a0)}
-}
-
-func (_c *S3API_CopyObject_Call) Run(run func(_a0 *s3.CopyObjectInput)) *S3API_CopyObject_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CopyObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CopyObject_Call) Return(_a0 *s3.CopyObjectOutput, _a1 error) *S3API_CopyObject_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CopyObject_Call) RunAndReturn(run func(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error)) *S3API_CopyObject_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CopyObjectRequest provides a mock function with given fields: _a0
-func (_m *S3API) CopyObjectRequest(_a0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CopyObjectRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.CopyObjectOutput
-	if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CopyObjectInput) *s3.CopyObjectOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.CopyObjectOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_CopyObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObjectRequest'
-type S3API_CopyObjectRequest_Call struct {
-	*mock.Call
-}
-
-// CopyObjectRequest is a helper method to define mock.On call
-//   - _a0 *s3.CopyObjectInput
-func (_e *S3API_Expecter) CopyObjectRequest(_a0 interface{}) *S3API_CopyObjectRequest_Call {
-	return &S3API_CopyObjectRequest_Call{Call: _e.mock.On("CopyObjectRequest", _a0)}
-}
-
-func (_c *S3API_CopyObjectRequest_Call) Run(run func(_a0 *s3.CopyObjectInput)) *S3API_CopyObjectRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CopyObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CopyObjectRequest_Call) Return(_a0 *request.Request, _a1 *s3.CopyObjectOutput) *S3API_CopyObjectRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CopyObjectRequest_Call) RunAndReturn(run func(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)) *S3API_CopyObjectRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CopyObjectWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) CopyObjectWithContext(_a0 aws.Context, _a1 *s3.CopyObjectInput, _a2 ...request.Option) (*s3.CopyObjectOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CopyObjectWithContext")
-	}
-
-	var r0 *s3.CopyObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CopyObjectInput, ...request.Option) (*s3.CopyObjectOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CopyObjectInput, ...request.Option) *s3.CopyObjectOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CopyObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.CopyObjectInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CopyObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObjectWithContext'
-type S3API_CopyObjectWithContext_Call struct {
-	*mock.Call
-}
-
-// CopyObjectWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.CopyObjectInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) CopyObjectWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_CopyObjectWithContext_Call {
-	return &S3API_CopyObjectWithContext_Call{Call: _e.mock.On("CopyObjectWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_CopyObjectWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.CopyObjectInput, _a2 ...request.Option)) *S3API_CopyObjectWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.CopyObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_CopyObjectWithContext_Call) Return(_a0 *s3.CopyObjectOutput, _a1 error) *S3API_CopyObjectWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CopyObjectWithContext_Call) RunAndReturn(run func(aws.Context, *s3.CopyObjectInput, ...request.Option) (*s3.CopyObjectOutput, error)) *S3API_CopyObjectWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateBucket provides a mock function with given fields: _a0
-func (_m *S3API) CreateBucket(_a0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateBucket")
-	}
-
-	var r0 *s3.CreateBucketOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) *s3.CreateBucketOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CreateBucketOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CreateBucketInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucket'
-type S3API_CreateBucket_Call struct {
-	*mock.Call
-}
-
-// CreateBucket is a helper method to define mock.On call
-//   - _a0 *s3.CreateBucketInput
-func (_e *S3API_Expecter) CreateBucket(_a0 interface{}) *S3API_CreateBucket_Call {
-	return &S3API_CreateBucket_Call{Call: _e.mock.On("CreateBucket", _a0)}
-}
-
-func (_c *S3API_CreateBucket_Call) Run(run func(_a0 *s3.CreateBucketInput)) *S3API_CreateBucket_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CreateBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CreateBucket_Call) Return(_a0 *s3.CreateBucketOutput, _a1 error) *S3API_CreateBucket_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateBucket_Call) RunAndReturn(run func(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error)) *S3API_CreateBucket_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateBucketRequest provides a mock function with given fields: _a0
-func (_m *S3API) CreateBucketRequest(_a0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateBucketRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.CreateBucketOutput
-	if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CreateBucketInput) *s3.CreateBucketOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.CreateBucketOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateBucketRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucketRequest'
-type S3API_CreateBucketRequest_Call struct {
-	*mock.Call
-}
-
-// CreateBucketRequest is a helper method to define mock.On call
-//   - _a0 *s3.CreateBucketInput
-func (_e *S3API_Expecter) CreateBucketRequest(_a0 interface{}) *S3API_CreateBucketRequest_Call {
-	return &S3API_CreateBucketRequest_Call{Call: _e.mock.On("CreateBucketRequest", _a0)}
-}
-
-func (_c *S3API_CreateBucketRequest_Call) Run(run func(_a0 *s3.CreateBucketInput)) *S3API_CreateBucketRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CreateBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CreateBucketRequest_Call) Return(_a0 *request.Request, _a1 *s3.CreateBucketOutput) *S3API_CreateBucketRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateBucketRequest_Call) RunAndReturn(run func(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)) *S3API_CreateBucketRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateBucketWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) CreateBucketWithContext(_a0 aws.Context, _a1 *s3.CreateBucketInput, _a2 ...request.Option) (*s3.CreateBucketOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateBucketWithContext")
-	}
-
-	var r0 *s3.CreateBucketOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CreateBucketInput, ...request.Option) (*s3.CreateBucketOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CreateBucketInput, ...request.Option) *s3.CreateBucketOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CreateBucketOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.CreateBucketInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateBucketWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucketWithContext'
-type S3API_CreateBucketWithContext_Call struct {
-	*mock.Call
-}
-
-// CreateBucketWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.CreateBucketInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) CreateBucketWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_CreateBucketWithContext_Call {
-	return &S3API_CreateBucketWithContext_Call{Call: _e.mock.On("CreateBucketWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_CreateBucketWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.CreateBucketInput, _a2 ...request.Option)) *S3API_CreateBucketWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.CreateBucketInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_CreateBucketWithContext_Call) Return(_a0 *s3.CreateBucketOutput, _a1 error) *S3API_CreateBucketWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateBucketWithContext_Call) RunAndReturn(run func(aws.Context, *s3.CreateBucketInput, ...request.Option) (*s3.CreateBucketOutput, error)) *S3API_CreateBucketWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateMultipartUpload provides a mock function with given fields: _a0
-func (_m *S3API) CreateMultipartUpload(_a0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateMultipartUpload")
-	}
-
-	var r0 *s3.CreateMultipartUploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) *s3.CreateMultipartUploadOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CreateMultipartUploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CreateMultipartUploadInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUpload'
-type S3API_CreateMultipartUpload_Call struct {
-	*mock.Call
-}
-
-// CreateMultipartUpload is a helper method to define mock.On call
-//   - _a0 *s3.CreateMultipartUploadInput
-func (_e *S3API_Expecter) CreateMultipartUpload(_a0 interface{}) *S3API_CreateMultipartUpload_Call {
-	return &S3API_CreateMultipartUpload_Call{Call: _e.mock.On("CreateMultipartUpload", _a0)}
-}
-
-func (_c *S3API_CreateMultipartUpload_Call) Run(run func(_a0 *s3.CreateMultipartUploadInput)) *S3API_CreateMultipartUpload_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CreateMultipartUploadInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CreateMultipartUpload_Call) Return(_a0 *s3.CreateMultipartUploadOutput, _a1 error) *S3API_CreateMultipartUpload_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateMultipartUpload_Call) RunAndReturn(run func(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)) *S3API_CreateMultipartUpload_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateMultipartUploadRequest provides a mock function with given fields: _a0
-func (_m *S3API) CreateMultipartUploadRequest(_a0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateMultipartUploadRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.CreateMultipartUploadOutput
-	if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CreateMultipartUploadInput) *s3.CreateMultipartUploadOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.CreateMultipartUploadOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateMultipartUploadRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUploadRequest'
-type S3API_CreateMultipartUploadRequest_Call struct {
-	*mock.Call
-}
-
-// CreateMultipartUploadRequest is a helper method to define mock.On call
-//   - _a0 *s3.CreateMultipartUploadInput
-func (_e *S3API_Expecter) CreateMultipartUploadRequest(_a0 interface{}) *S3API_CreateMultipartUploadRequest_Call {
-	return &S3API_CreateMultipartUploadRequest_Call{Call: _e.mock.On("CreateMultipartUploadRequest", _a0)}
-}
-
-func (_c *S3API_CreateMultipartUploadRequest_Call) Run(run func(_a0 *s3.CreateMultipartUploadInput)) *S3API_CreateMultipartUploadRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CreateMultipartUploadInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CreateMultipartUploadRequest_Call) Return(_a0 *request.Request, _a1 *s3.CreateMultipartUploadOutput) *S3API_CreateMultipartUploadRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateMultipartUploadRequest_Call) RunAndReturn(run func(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)) *S3API_CreateMultipartUploadRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateMultipartUploadWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) CreateMultipartUploadWithContext(_a0 aws.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...request.Option) (*s3.CreateMultipartUploadOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateMultipartUploadWithContext")
-	}
-
-	var r0 *s3.CreateMultipartUploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) (*s3.CreateMultipartUploadOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) *s3.CreateMultipartUploadOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CreateMultipartUploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateMultipartUploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUploadWithContext'
-type S3API_CreateMultipartUploadWithContext_Call struct {
-	*mock.Call
-}
-
-// CreateMultipartUploadWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.CreateMultipartUploadInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) CreateMultipartUploadWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_CreateMultipartUploadWithContext_Call {
-	return &S3API_CreateMultipartUploadWithContext_Call{Call: _e.mock.On("CreateMultipartUploadWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_CreateMultipartUploadWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...request.Option)) *S3API_CreateMultipartUploadWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.CreateMultipartUploadInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_CreateMultipartUploadWithContext_Call) Return(_a0 *s3.CreateMultipartUploadOutput, _a1 error) *S3API_CreateMultipartUploadWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateMultipartUploadWithContext_Call) RunAndReturn(run func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) (*s3.CreateMultipartUploadOutput, error)) *S3API_CreateMultipartUploadWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSession provides a mock function with given fields: _a0
-func (_m *S3API) CreateSession(_a0 *s3.CreateSessionInput) (*s3.CreateSessionOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSession")
-	}
-
-	var r0 *s3.CreateSessionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) (*s3.CreateSessionOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) *s3.CreateSessionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CreateSessionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CreateSessionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession'
-type S3API_CreateSession_Call struct {
-	*mock.Call
-}
-
-// CreateSession is a helper method to define mock.On call
-//   - _a0 *s3.CreateSessionInput
-func (_e *S3API_Expecter) CreateSession(_a0 interface{}) *S3API_CreateSession_Call {
-	return &S3API_CreateSession_Call{Call: _e.mock.On("CreateSession", _a0)}
-}
-
-func (_c *S3API_CreateSession_Call) Run(run func(_a0 *s3.CreateSessionInput)) *S3API_CreateSession_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CreateSessionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CreateSession_Call) Return(_a0 *s3.CreateSessionOutput, _a1 error) *S3API_CreateSession_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateSession_Call) RunAndReturn(run func(*s3.CreateSessionInput) (*s3.CreateSessionOutput, error)) *S3API_CreateSession_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSessionRequest provides a mock function with given fields: _a0
-func (_m *S3API) CreateSessionRequest(_a0 *s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSessionRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.CreateSessionOutput
-	if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.CreateSessionInput) *s3.CreateSessionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.CreateSessionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateSessionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionRequest'
-type S3API_CreateSessionRequest_Call struct {
-	*mock.Call
-}
-
-// CreateSessionRequest is a helper method to define mock.On call
-//   - _a0 *s3.CreateSessionInput
-func (_e *S3API_Expecter) CreateSessionRequest(_a0 interface{}) *S3API_CreateSessionRequest_Call {
-	return &S3API_CreateSessionRequest_Call{Call: _e.mock.On("CreateSessionRequest", _a0)}
-}
-
-func (_c *S3API_CreateSessionRequest_Call) Run(run func(_a0 *s3.CreateSessionInput)) *S3API_CreateSessionRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.CreateSessionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_CreateSessionRequest_Call) Return(_a0 *request.Request, _a1 *s3.CreateSessionOutput) *S3API_CreateSessionRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateSessionRequest_Call) RunAndReturn(run func(*s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput)) *S3API_CreateSessionRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) CreateSessionWithContext(_a0 aws.Context, _a1 *s3.CreateSessionInput, _a2 ...request.Option) (*s3.CreateSessionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSessionWithContext")
-	}
-
-	var r0 *s3.CreateSessionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CreateSessionInput, ...request.Option) (*s3.CreateSessionOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.CreateSessionInput, ...request.Option) *s3.CreateSessionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.CreateSessionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.CreateSessionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_CreateSessionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionWithContext'
-type S3API_CreateSessionWithContext_Call struct {
-	*mock.Call
-}
-
-// CreateSessionWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.CreateSessionInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) CreateSessionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_CreateSessionWithContext_Call {
-	return &S3API_CreateSessionWithContext_Call{Call: _e.mock.On("CreateSessionWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_CreateSessionWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.CreateSessionInput, _a2 ...request.Option)) *S3API_CreateSessionWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.CreateSessionInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_CreateSessionWithContext_Call) Return(_a0 *s3.CreateSessionOutput, _a1 error) *S3API_CreateSessionWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_CreateSessionWithContext_Call) RunAndReturn(run func(aws.Context, *s3.CreateSessionInput, ...request.Option) (*s3.CreateSessionOutput, error)) *S3API_CreateSessionWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucket provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucket(_a0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucket")
-	}
-
-	var r0 *s3.DeleteBucketOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) *s3.DeleteBucketOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucket'
-type S3API_DeleteBucket_Call struct {
-	*mock.Call
-}
-
-// DeleteBucket is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketInput
-func (_e *S3API_Expecter) DeleteBucket(_a0 interface{}) *S3API_DeleteBucket_Call {
-	return &S3API_DeleteBucket_Call{Call: _e.mock.On("DeleteBucket", _a0)}
-}
-
-func (_c *S3API_DeleteBucket_Call) Run(run func(_a0 *s3.DeleteBucketInput)) *S3API_DeleteBucket_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucket_Call) Return(_a0 *s3.DeleteBucketOutput, _a1 error) *S3API_DeleteBucket_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucket_Call) RunAndReturn(run func(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)) *S3API_DeleteBucket_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketAnalyticsConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketAnalyticsConfiguration(_a0 *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketAnalyticsConfiguration")
-	}
-
-	var r0 *s3.DeleteBucketAnalyticsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *s3.DeleteBucketAnalyticsConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketAnalyticsConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketAnalyticsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketAnalyticsConfiguration'
-type S3API_DeleteBucketAnalyticsConfiguration_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketAnalyticsConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketAnalyticsConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketAnalyticsConfiguration(_a0 interface{}) *S3API_DeleteBucketAnalyticsConfiguration_Call {
-	return &S3API_DeleteBucketAnalyticsConfiguration_Call{Call: _e.mock.On("DeleteBucketAnalyticsConfiguration", _a0)}
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfiguration_Call) Run(run func(_a0 *s3.DeleteBucketAnalyticsConfigurationInput)) *S3API_DeleteBucketAnalyticsConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketAnalyticsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfiguration_Call) Return(_a0 *s3.DeleteBucketAnalyticsConfigurationOutput, _a1 error) *S3API_DeleteBucketAnalyticsConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfiguration_Call) RunAndReturn(run func(*s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)) *S3API_DeleteBucketAnalyticsConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketAnalyticsConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketAnalyticsConfigurationRequest(_a0 *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketAnalyticsConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketAnalyticsConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *s3.DeleteBucketAnalyticsConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketAnalyticsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketAnalyticsConfigurationRequest'
-type S3API_DeleteBucketAnalyticsConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketAnalyticsConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketAnalyticsConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketAnalyticsConfigurationRequest(_a0 interface{}) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call {
-	return &S3API_DeleteBucketAnalyticsConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketAnalyticsConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfigurationRequest_Call) Run(run func(_a0 *s3.DeleteBucketAnalyticsConfigurationInput)) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketAnalyticsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketAnalyticsConfigurationOutput) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfigurationRequest_Call) RunAndReturn(run func(*s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput)) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketAnalyticsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketAnalyticsConfigurationWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketAnalyticsConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketAnalyticsConfigurationWithContext")
-	}
-
-	var r0 *s3.DeleteBucketAnalyticsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) *s3.DeleteBucketAnalyticsConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketAnalyticsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketAnalyticsConfigurationWithContext'
-type S3API_DeleteBucketAnalyticsConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketAnalyticsConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketAnalyticsConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketAnalyticsConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call {
-	return &S3API_DeleteBucketAnalyticsConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketAnalyticsConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketAnalyticsConfigurationInput, _a2 ...request.Option)) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketAnalyticsConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call) Return(_a0 *s3.DeleteBucketAnalyticsConfigurationOutput, _a1 error) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketCors provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketCors(_a0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketCors")
-	}
-
-	var r0 *s3.DeleteBucketCorsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) *s3.DeleteBucketCorsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketCorsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketCorsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketCors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketCors'
-type S3API_DeleteBucketCors_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketCors is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketCorsInput
-func (_e *S3API_Expecter) DeleteBucketCors(_a0 interface{}) *S3API_DeleteBucketCors_Call {
-	return &S3API_DeleteBucketCors_Call{Call: _e.mock.On("DeleteBucketCors", _a0)}
-}
-
-func (_c *S3API_DeleteBucketCors_Call) Run(run func(_a0 *s3.DeleteBucketCorsInput)) *S3API_DeleteBucketCors_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketCorsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketCors_Call) Return(_a0 *s3.DeleteBucketCorsOutput, _a1 error) *S3API_DeleteBucketCors_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketCors_Call) RunAndReturn(run func(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)) *S3API_DeleteBucketCors_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketCorsRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketCorsRequest(_a0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketCorsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketCorsOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketCorsInput) *s3.DeleteBucketCorsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketCorsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketCorsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketCorsRequest'
-type S3API_DeleteBucketCorsRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketCorsRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketCorsInput
-func (_e *S3API_Expecter) DeleteBucketCorsRequest(_a0 interface{}) *S3API_DeleteBucketCorsRequest_Call {
-	return &S3API_DeleteBucketCorsRequest_Call{Call: _e.mock.On("DeleteBucketCorsRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketCorsRequest_Call) Run(run func(_a0 *s3.DeleteBucketCorsInput)) *S3API_DeleteBucketCorsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketCorsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketCorsRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketCorsOutput) *S3API_DeleteBucketCorsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketCorsRequest_Call) RunAndReturn(run func(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)) *S3API_DeleteBucketCorsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketCorsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketCorsWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketCorsInput, _a2 ...request.Option) (*s3.DeleteBucketCorsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketCorsWithContext")
-	}
-
-	var r0 *s3.DeleteBucketCorsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) *s3.DeleteBucketCorsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketCorsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketCorsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketCorsWithContext'
-type S3API_DeleteBucketCorsWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketCorsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketCorsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketCorsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketCorsWithContext_Call {
-	return &S3API_DeleteBucketCorsWithContext_Call{Call: _e.mock.On("DeleteBucketCorsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketCorsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketCorsInput, _a2 ...request.Option)) *S3API_DeleteBucketCorsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketCorsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketCorsWithContext_Call) Return(_a0 *s3.DeleteBucketCorsOutput, _a1 error) *S3API_DeleteBucketCorsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketCorsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error)) *S3API_DeleteBucketCorsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketEncryption provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketEncryption(_a0 *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketEncryption")
-	}
-
-	var r0 *s3.DeleteBucketEncryptionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) *s3.DeleteBucketEncryptionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketEncryptionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketEncryptionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketEncryption'
-type S3API_DeleteBucketEncryption_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketEncryption is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketEncryptionInput
-func (_e *S3API_Expecter) DeleteBucketEncryption(_a0 interface{}) *S3API_DeleteBucketEncryption_Call {
-	return &S3API_DeleteBucketEncryption_Call{Call: _e.mock.On("DeleteBucketEncryption", _a0)}
-}
-
-func (_c *S3API_DeleteBucketEncryption_Call) Run(run func(_a0 *s3.DeleteBucketEncryptionInput)) *S3API_DeleteBucketEncryption_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketEncryptionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketEncryption_Call) Return(_a0 *s3.DeleteBucketEncryptionOutput, _a1 error) *S3API_DeleteBucketEncryption_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketEncryption_Call) RunAndReturn(run func(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)) *S3API_DeleteBucketEncryption_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketEncryptionRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketEncryptionRequest(_a0 *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketEncryptionRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketEncryptionOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketEncryptionInput) *s3.DeleteBucketEncryptionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketEncryptionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketEncryptionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketEncryptionRequest'
-type S3API_DeleteBucketEncryptionRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketEncryptionRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketEncryptionInput
-func (_e *S3API_Expecter) DeleteBucketEncryptionRequest(_a0 interface{}) *S3API_DeleteBucketEncryptionRequest_Call {
-	return &S3API_DeleteBucketEncryptionRequest_Call{Call: _e.mock.On("DeleteBucketEncryptionRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketEncryptionRequest_Call) Run(run func(_a0 *s3.DeleteBucketEncryptionInput)) *S3API_DeleteBucketEncryptionRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketEncryptionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketEncryptionRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketEncryptionOutput) *S3API_DeleteBucketEncryptionRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketEncryptionRequest_Call) RunAndReturn(run func(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)) *S3API_DeleteBucketEncryptionRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketEncryptionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketEncryptionWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketEncryptionInput, _a2 ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketEncryptionWithContext")
-	}
-
-	var r0 *s3.DeleteBucketEncryptionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) *s3.DeleteBucketEncryptionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketEncryptionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketEncryptionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketEncryptionWithContext'
-type S3API_DeleteBucketEncryptionWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketEncryptionWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketEncryptionInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketEncryptionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketEncryptionWithContext_Call {
-	return &S3API_DeleteBucketEncryptionWithContext_Call{Call: _e.mock.On("DeleteBucketEncryptionWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketEncryptionWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketEncryptionInput, _a2 ...request.Option)) *S3API_DeleteBucketEncryptionWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketEncryptionInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketEncryptionWithContext_Call) Return(_a0 *s3.DeleteBucketEncryptionOutput, _a1 error) *S3API_DeleteBucketEncryptionWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketEncryptionWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)) *S3API_DeleteBucketEncryptionWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketIntelligentTieringConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketIntelligentTieringConfiguration(_a0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketIntelligentTieringConfiguration")
-	}
-
-	var r0 *s3.DeleteBucketIntelligentTieringConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketIntelligentTieringConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketIntelligentTieringConfiguration'
-type S3API_DeleteBucketIntelligentTieringConfiguration_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketIntelligentTieringConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketIntelligentTieringConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketIntelligentTieringConfiguration(_a0 interface{}) *S3API_DeleteBucketIntelligentTieringConfiguration_Call {
-	return &S3API_DeleteBucketIntelligentTieringConfiguration_Call{Call: _e.mock.On("DeleteBucketIntelligentTieringConfiguration", _a0)}
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfiguration_Call) Run(run func(_a0 *s3.DeleteBucketIntelligentTieringConfigurationInput)) *S3API_DeleteBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketIntelligentTieringConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfiguration_Call) Return(_a0 *s3.DeleteBucketIntelligentTieringConfigurationOutput, _a1 error) *S3API_DeleteBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfiguration_Call) RunAndReturn(run func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)) *S3API_DeleteBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketIntelligentTieringConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketIntelligentTieringConfigurationRequest(_a0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketIntelligentTieringConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketIntelligentTieringConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketIntelligentTieringConfigurationRequest'
-type S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketIntelligentTieringConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketIntelligentTieringConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketIntelligentTieringConfigurationRequest(_a0 interface{}) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call {
-	return &S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketIntelligentTieringConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call) Run(run func(_a0 *s3.DeleteBucketIntelligentTieringConfigurationInput)) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketIntelligentTieringConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketIntelligentTieringConfigurationOutput) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call) RunAndReturn(run func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput)) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketIntelligentTieringConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketIntelligentTieringConfigurationWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketIntelligentTieringConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketIntelligentTieringConfigurationWithContext")
-	}
-
-	var r0 *s3.DeleteBucketIntelligentTieringConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketIntelligentTieringConfigurationWithContext'
-type S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketIntelligentTieringConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketIntelligentTieringConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketIntelligentTieringConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call {
-	return &S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketIntelligentTieringConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketIntelligentTieringConfigurationInput, _a2 ...request.Option)) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketIntelligentTieringConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call) Return(_a0 *s3.DeleteBucketIntelligentTieringConfigurationOutput, _a1 error) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketInventoryConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketInventoryConfiguration(_a0 *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketInventoryConfiguration")
-	}
-
-	var r0 *s3.DeleteBucketInventoryConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) *s3.DeleteBucketInventoryConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketInventoryConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInventoryConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketInventoryConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketInventoryConfiguration'
-type S3API_DeleteBucketInventoryConfiguration_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketInventoryConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketInventoryConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketInventoryConfiguration(_a0 interface{}) *S3API_DeleteBucketInventoryConfiguration_Call {
-	return &S3API_DeleteBucketInventoryConfiguration_Call{Call: _e.mock.On("DeleteBucketInventoryConfiguration", _a0)}
-}
-
-func (_c *S3API_DeleteBucketInventoryConfiguration_Call) Run(run func(_a0 *s3.DeleteBucketInventoryConfigurationInput)) *S3API_DeleteBucketInventoryConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketInventoryConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketInventoryConfiguration_Call) Return(_a0 *s3.DeleteBucketInventoryConfigurationOutput, _a1 error) *S3API_DeleteBucketInventoryConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketInventoryConfiguration_Call) RunAndReturn(run func(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)) *S3API_DeleteBucketInventoryConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketInventoryConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketInventoryConfigurationRequest(_a0 *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketInventoryConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketInventoryConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInventoryConfigurationInput) *s3.DeleteBucketInventoryConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketInventoryConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketInventoryConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketInventoryConfigurationRequest'
-type S3API_DeleteBucketInventoryConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketInventoryConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketInventoryConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketInventoryConfigurationRequest(_a0 interface{}) *S3API_DeleteBucketInventoryConfigurationRequest_Call {
-	return &S3API_DeleteBucketInventoryConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketInventoryConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketInventoryConfigurationRequest_Call) Run(run func(_a0 *s3.DeleteBucketInventoryConfigurationInput)) *S3API_DeleteBucketInventoryConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketInventoryConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketInventoryConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketInventoryConfigurationOutput) *S3API_DeleteBucketInventoryConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketInventoryConfigurationRequest_Call) RunAndReturn(run func(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)) *S3API_DeleteBucketInventoryConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketInventoryConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketInventoryConfigurationWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketInventoryConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketInventoryConfigurationWithContext")
-	}
-
-	var r0 *s3.DeleteBucketInventoryConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) *s3.DeleteBucketInventoryConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketInventoryConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketInventoryConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketInventoryConfigurationWithContext'
-type S3API_DeleteBucketInventoryConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketInventoryConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketInventoryConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketInventoryConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketInventoryConfigurationWithContext_Call {
-	return &S3API_DeleteBucketInventoryConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketInventoryConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketInventoryConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketInventoryConfigurationInput, _a2 ...request.Option)) *S3API_DeleteBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketInventoryConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketInventoryConfigurationWithContext_Call) Return(_a0 *s3.DeleteBucketInventoryConfigurationOutput, _a1 error) *S3API_DeleteBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketInventoryConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)) *S3API_DeleteBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketLifecycle provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketLifecycle(_a0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketLifecycle")
-	}
-
-	var r0 *s3.DeleteBucketLifecycleOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) *s3.DeleteBucketLifecycleOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketLifecycleOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketLifecycleInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycle'
-type S3API_DeleteBucketLifecycle_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketLifecycle is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketLifecycleInput
-func (_e *S3API_Expecter) DeleteBucketLifecycle(_a0 interface{}) *S3API_DeleteBucketLifecycle_Call {
-	return &S3API_DeleteBucketLifecycle_Call{Call: _e.mock.On("DeleteBucketLifecycle", _a0)}
-}
-
-func (_c *S3API_DeleteBucketLifecycle_Call) Run(run func(_a0 *s3.DeleteBucketLifecycleInput)) *S3API_DeleteBucketLifecycle_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketLifecycleInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketLifecycle_Call) Return(_a0 *s3.DeleteBucketLifecycleOutput, _a1 error) *S3API_DeleteBucketLifecycle_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketLifecycle_Call) RunAndReturn(run func(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)) *S3API_DeleteBucketLifecycle_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketLifecycleRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketLifecycleRequest(_a0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketLifecycleRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketLifecycleOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketLifecycleInput) *s3.DeleteBucketLifecycleOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketLifecycleOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketLifecycleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycleRequest'
-type S3API_DeleteBucketLifecycleRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketLifecycleRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketLifecycleInput
-func (_e *S3API_Expecter) DeleteBucketLifecycleRequest(_a0 interface{}) *S3API_DeleteBucketLifecycleRequest_Call {
-	return &S3API_DeleteBucketLifecycleRequest_Call{Call: _e.mock.On("DeleteBucketLifecycleRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketLifecycleRequest_Call) Run(run func(_a0 *s3.DeleteBucketLifecycleInput)) *S3API_DeleteBucketLifecycleRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketLifecycleInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketLifecycleRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketLifecycleOutput) *S3API_DeleteBucketLifecycleRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketLifecycleRequest_Call) RunAndReturn(run func(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)) *S3API_DeleteBucketLifecycleRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketLifecycleWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketLifecycleWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketLifecycleInput, _a2 ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketLifecycleWithContext")
-	}
-
-	var r0 *s3.DeleteBucketLifecycleOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) (*s3.DeleteBucketLifecycleOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) *s3.DeleteBucketLifecycleOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketLifecycleOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketLifecycleWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycleWithContext'
-type S3API_DeleteBucketLifecycleWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketLifecycleWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketLifecycleInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketLifecycleWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketLifecycleWithContext_Call {
-	return &S3API_DeleteBucketLifecycleWithContext_Call{Call: _e.mock.On("DeleteBucketLifecycleWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketLifecycleWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketLifecycleInput, _a2 ...request.Option)) *S3API_DeleteBucketLifecycleWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketLifecycleInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketLifecycleWithContext_Call) Return(_a0 *s3.DeleteBucketLifecycleOutput, _a1 error) *S3API_DeleteBucketLifecycleWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketLifecycleWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) (*s3.DeleteBucketLifecycleOutput, error)) *S3API_DeleteBucketLifecycleWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketMetricsConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketMetricsConfiguration(_a0 *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketMetricsConfiguration")
-	}
-
-	var r0 *s3.DeleteBucketMetricsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) *s3.DeleteBucketMetricsConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketMetricsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketMetricsConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketMetricsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketMetricsConfiguration'
-type S3API_DeleteBucketMetricsConfiguration_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketMetricsConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketMetricsConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketMetricsConfiguration(_a0 interface{}) *S3API_DeleteBucketMetricsConfiguration_Call {
-	return &S3API_DeleteBucketMetricsConfiguration_Call{Call: _e.mock.On("DeleteBucketMetricsConfiguration", _a0)}
-}
-
-func (_c *S3API_DeleteBucketMetricsConfiguration_Call) Run(run func(_a0 *s3.DeleteBucketMetricsConfigurationInput)) *S3API_DeleteBucketMetricsConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketMetricsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketMetricsConfiguration_Call) Return(_a0 *s3.DeleteBucketMetricsConfigurationOutput, _a1 error) *S3API_DeleteBucketMetricsConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketMetricsConfiguration_Call) RunAndReturn(run func(*s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error)) *S3API_DeleteBucketMetricsConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketMetricsConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketMetricsConfigurationRequest(_a0 *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketMetricsConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketMetricsConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketMetricsConfigurationInput) *s3.DeleteBucketMetricsConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketMetricsConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketMetricsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketMetricsConfigurationRequest'
-type S3API_DeleteBucketMetricsConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketMetricsConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketMetricsConfigurationInput
-func (_e *S3API_Expecter) DeleteBucketMetricsConfigurationRequest(_a0 interface{}) *S3API_DeleteBucketMetricsConfigurationRequest_Call {
-	return &S3API_DeleteBucketMetricsConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketMetricsConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketMetricsConfigurationRequest_Call) Run(run func(_a0 *s3.DeleteBucketMetricsConfigurationInput)) *S3API_DeleteBucketMetricsConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketMetricsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketMetricsConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketMetricsConfigurationOutput) *S3API_DeleteBucketMetricsConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketMetricsConfigurationRequest_Call) RunAndReturn(run func(*s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput)) *S3API_DeleteBucketMetricsConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketMetricsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketMetricsConfigurationWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketMetricsConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketMetricsConfigurationWithContext")
-	}
-
-	var r0 *s3.DeleteBucketMetricsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) *s3.DeleteBucketMetricsConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketMetricsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketMetricsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketMetricsConfigurationWithContext'
-type S3API_DeleteBucketMetricsConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketMetricsConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketMetricsConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketMetricsConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketMetricsConfigurationWithContext_Call {
-	return &S3API_DeleteBucketMetricsConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketMetricsConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketMetricsConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketMetricsConfigurationInput, _a2 ...request.Option)) *S3API_DeleteBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketMetricsConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketMetricsConfigurationWithContext_Call) Return(_a0 *s3.DeleteBucketMetricsConfigurationOutput, _a1 error) *S3API_DeleteBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketMetricsConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error)) *S3API_DeleteBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketOwnershipControls provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketOwnershipControls(_a0 *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketOwnershipControls")
-	}
-
-	var r0 *s3.DeleteBucketOwnershipControlsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) *s3.DeleteBucketOwnershipControlsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketOwnershipControlsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketOwnershipControlsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketOwnershipControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketOwnershipControls'
-type S3API_DeleteBucketOwnershipControls_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketOwnershipControls is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketOwnershipControlsInput
-func (_e *S3API_Expecter) DeleteBucketOwnershipControls(_a0 interface{}) *S3API_DeleteBucketOwnershipControls_Call {
-	return &S3API_DeleteBucketOwnershipControls_Call{Call: _e.mock.On("DeleteBucketOwnershipControls", _a0)}
-}
-
-func (_c *S3API_DeleteBucketOwnershipControls_Call) Run(run func(_a0 *s3.DeleteBucketOwnershipControlsInput)) *S3API_DeleteBucketOwnershipControls_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketOwnershipControlsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketOwnershipControls_Call) Return(_a0 *s3.DeleteBucketOwnershipControlsOutput, _a1 error) *S3API_DeleteBucketOwnershipControls_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketOwnershipControls_Call) RunAndReturn(run func(*s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error)) *S3API_DeleteBucketOwnershipControls_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketOwnershipControlsRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketOwnershipControlsRequest(_a0 *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketOwnershipControlsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketOwnershipControlsOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketOwnershipControlsInput) *s3.DeleteBucketOwnershipControlsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketOwnershipControlsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketOwnershipControlsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketOwnershipControlsRequest'
-type S3API_DeleteBucketOwnershipControlsRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketOwnershipControlsRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketOwnershipControlsInput
-func (_e *S3API_Expecter) DeleteBucketOwnershipControlsRequest(_a0 interface{}) *S3API_DeleteBucketOwnershipControlsRequest_Call {
-	return &S3API_DeleteBucketOwnershipControlsRequest_Call{Call: _e.mock.On("DeleteBucketOwnershipControlsRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketOwnershipControlsRequest_Call) Run(run func(_a0 *s3.DeleteBucketOwnershipControlsInput)) *S3API_DeleteBucketOwnershipControlsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketOwnershipControlsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketOwnershipControlsRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketOwnershipControlsOutput) *S3API_DeleteBucketOwnershipControlsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketOwnershipControlsRequest_Call) RunAndReturn(run func(*s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput)) *S3API_DeleteBucketOwnershipControlsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketOwnershipControlsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketOwnershipControlsWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketOwnershipControlsInput, _a2 ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketOwnershipControlsWithContext")
-	}
-
-	var r0 *s3.DeleteBucketOwnershipControlsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) *s3.DeleteBucketOwnershipControlsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketOwnershipControlsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketOwnershipControlsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketOwnershipControlsWithContext'
-type S3API_DeleteBucketOwnershipControlsWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketOwnershipControlsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketOwnershipControlsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketOwnershipControlsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketOwnershipControlsWithContext_Call {
-	return &S3API_DeleteBucketOwnershipControlsWithContext_Call{Call: _e.mock.On("DeleteBucketOwnershipControlsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketOwnershipControlsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketOwnershipControlsInput, _a2 ...request.Option)) *S3API_DeleteBucketOwnershipControlsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketOwnershipControlsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketOwnershipControlsWithContext_Call) Return(_a0 *s3.DeleteBucketOwnershipControlsOutput, _a1 error) *S3API_DeleteBucketOwnershipControlsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketOwnershipControlsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error)) *S3API_DeleteBucketOwnershipControlsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketPolicy provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketPolicy(_a0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketPolicy")
-	}
-
-	var r0 *s3.DeleteBucketPolicyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) *s3.DeleteBucketPolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketPolicyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketPolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketPolicy'
-type S3API_DeleteBucketPolicy_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketPolicy is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketPolicyInput
-func (_e *S3API_Expecter) DeleteBucketPolicy(_a0 interface{}) *S3API_DeleteBucketPolicy_Call {
-	return &S3API_DeleteBucketPolicy_Call{Call: _e.mock.On("DeleteBucketPolicy", _a0)}
-}
-
-func (_c *S3API_DeleteBucketPolicy_Call) Run(run func(_a0 *s3.DeleteBucketPolicyInput)) *S3API_DeleteBucketPolicy_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketPolicyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketPolicy_Call) Return(_a0 *s3.DeleteBucketPolicyOutput, _a1 error) *S3API_DeleteBucketPolicy_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketPolicy_Call) RunAndReturn(run func(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)) *S3API_DeleteBucketPolicy_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketPolicyRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketPolicyRequest(_a0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketPolicyRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketPolicyOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketPolicyInput) *s3.DeleteBucketPolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketPolicyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketPolicyRequest'
-type S3API_DeleteBucketPolicyRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketPolicyRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketPolicyInput
-func (_e *S3API_Expecter) DeleteBucketPolicyRequest(_a0 interface{}) *S3API_DeleteBucketPolicyRequest_Call {
-	return &S3API_DeleteBucketPolicyRequest_Call{Call: _e.mock.On("DeleteBucketPolicyRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketPolicyRequest_Call) Run(run func(_a0 *s3.DeleteBucketPolicyInput)) *S3API_DeleteBucketPolicyRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketPolicyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketPolicyRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketPolicyOutput) *S3API_DeleteBucketPolicyRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketPolicyRequest_Call) RunAndReturn(run func(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)) *S3API_DeleteBucketPolicyRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketPolicyWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketPolicyInput, _a2 ...request.Option) (*s3.DeleteBucketPolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketPolicyWithContext")
-	}
-
-	var r0 *s3.DeleteBucketPolicyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) (*s3.DeleteBucketPolicyOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) *s3.DeleteBucketPolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketPolicyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketPolicyWithContext'
-type S3API_DeleteBucketPolicyWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketPolicyWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketPolicyInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketPolicyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketPolicyWithContext_Call {
-	return &S3API_DeleteBucketPolicyWithContext_Call{Call: _e.mock.On("DeleteBucketPolicyWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketPolicyWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketPolicyInput, _a2 ...request.Option)) *S3API_DeleteBucketPolicyWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketPolicyInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketPolicyWithContext_Call) Return(_a0 *s3.DeleteBucketPolicyOutput, _a1 error) *S3API_DeleteBucketPolicyWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketPolicyWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) (*s3.DeleteBucketPolicyOutput, error)) *S3API_DeleteBucketPolicyWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketReplication provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketReplication(_a0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketReplication")
-	}
-
-	var r0 *s3.DeleteBucketReplicationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) *s3.DeleteBucketReplicationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketReplicationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketReplicationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketReplication'
-type S3API_DeleteBucketReplication_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketReplication is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketReplicationInput
-func (_e *S3API_Expecter) DeleteBucketReplication(_a0 interface{}) *S3API_DeleteBucketReplication_Call {
-	return &S3API_DeleteBucketReplication_Call{Call: _e.mock.On("DeleteBucketReplication", _a0)}
-}
-
-func (_c *S3API_DeleteBucketReplication_Call) Run(run func(_a0 *s3.DeleteBucketReplicationInput)) *S3API_DeleteBucketReplication_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketReplicationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketReplication_Call) Return(_a0 *s3.DeleteBucketReplicationOutput, _a1 error) *S3API_DeleteBucketReplication_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketReplication_Call) RunAndReturn(run func(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)) *S3API_DeleteBucketReplication_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketReplicationRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketReplicationRequest(_a0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketReplicationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketReplicationOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketReplicationInput) *s3.DeleteBucketReplicationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketReplicationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketReplicationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketReplicationRequest'
-type S3API_DeleteBucketReplicationRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketReplicationRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketReplicationInput
-func (_e *S3API_Expecter) DeleteBucketReplicationRequest(_a0 interface{}) *S3API_DeleteBucketReplicationRequest_Call {
-	return &S3API_DeleteBucketReplicationRequest_Call{Call: _e.mock.On("DeleteBucketReplicationRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketReplicationRequest_Call) Run(run func(_a0 *s3.DeleteBucketReplicationInput)) *S3API_DeleteBucketReplicationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketReplicationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketReplicationRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketReplicationOutput) *S3API_DeleteBucketReplicationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketReplicationRequest_Call) RunAndReturn(run func(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)) *S3API_DeleteBucketReplicationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketReplicationWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketReplicationInput, _a2 ...request.Option) (*s3.DeleteBucketReplicationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketReplicationWithContext")
-	}
-
-	var r0 *s3.DeleteBucketReplicationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) (*s3.DeleteBucketReplicationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) *s3.DeleteBucketReplicationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketReplicationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketReplicationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketReplicationWithContext'
-type S3API_DeleteBucketReplicationWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketReplicationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketReplicationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketReplicationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketReplicationWithContext_Call {
-	return &S3API_DeleteBucketReplicationWithContext_Call{Call: _e.mock.On("DeleteBucketReplicationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketReplicationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketReplicationInput, _a2 ...request.Option)) *S3API_DeleteBucketReplicationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketReplicationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketReplicationWithContext_Call) Return(_a0 *s3.DeleteBucketReplicationOutput, _a1 error) *S3API_DeleteBucketReplicationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketReplicationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) (*s3.DeleteBucketReplicationOutput, error)) *S3API_DeleteBucketReplicationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketRequest(_a0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInput) *s3.DeleteBucketOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketRequest'
-type S3API_DeleteBucketRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketInput
-func (_e *S3API_Expecter) DeleteBucketRequest(_a0 interface{}) *S3API_DeleteBucketRequest_Call {
-	return &S3API_DeleteBucketRequest_Call{Call: _e.mock.On("DeleteBucketRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketRequest_Call) Run(run func(_a0 *s3.DeleteBucketInput)) *S3API_DeleteBucketRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketOutput) *S3API_DeleteBucketRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketRequest_Call) RunAndReturn(run func(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)) *S3API_DeleteBucketRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketTagging provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketTagging(_a0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketTagging")
-	}
-
-	var r0 *s3.DeleteBucketTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) *s3.DeleteBucketTaggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketTaggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketTagging'
-type S3API_DeleteBucketTagging_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketTagging is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketTaggingInput
-func (_e *S3API_Expecter) DeleteBucketTagging(_a0 interface{}) *S3API_DeleteBucketTagging_Call {
-	return &S3API_DeleteBucketTagging_Call{Call: _e.mock.On("DeleteBucketTagging", _a0)}
-}
-
-func (_c *S3API_DeleteBucketTagging_Call) Run(run func(_a0 *s3.DeleteBucketTaggingInput)) *S3API_DeleteBucketTagging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketTagging_Call) Return(_a0 *s3.DeleteBucketTaggingOutput, _a1 error) *S3API_DeleteBucketTagging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketTagging_Call) RunAndReturn(run func(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)) *S3API_DeleteBucketTagging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketTaggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketTaggingRequest(_a0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketTaggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketTaggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketTaggingInput) *s3.DeleteBucketTaggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketTaggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketTaggingRequest'
-type S3API_DeleteBucketTaggingRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketTaggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketTaggingInput
-func (_e *S3API_Expecter) DeleteBucketTaggingRequest(_a0 interface{}) *S3API_DeleteBucketTaggingRequest_Call {
-	return &S3API_DeleteBucketTaggingRequest_Call{Call: _e.mock.On("DeleteBucketTaggingRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketTaggingRequest_Call) Run(run func(_a0 *s3.DeleteBucketTaggingInput)) *S3API_DeleteBucketTaggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketTaggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketTaggingOutput) *S3API_DeleteBucketTaggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketTaggingRequest_Call) RunAndReturn(run func(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)) *S3API_DeleteBucketTaggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketTaggingWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketTaggingInput, _a2 ...request.Option) (*s3.DeleteBucketTaggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketTaggingWithContext")
-	}
-
-	var r0 *s3.DeleteBucketTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) (*s3.DeleteBucketTaggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) *s3.DeleteBucketTaggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketTaggingWithContext'
-type S3API_DeleteBucketTaggingWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketTaggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketTaggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketTaggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketTaggingWithContext_Call {
-	return &S3API_DeleteBucketTaggingWithContext_Call{Call: _e.mock.On("DeleteBucketTaggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketTaggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketTaggingInput, _a2 ...request.Option)) *S3API_DeleteBucketTaggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketTaggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketTaggingWithContext_Call) Return(_a0 *s3.DeleteBucketTaggingOutput, _a1 error) *S3API_DeleteBucketTaggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketTaggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) (*s3.DeleteBucketTaggingOutput, error)) *S3API_DeleteBucketTaggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketWebsite provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketWebsite(_a0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketWebsite")
-	}
-
-	var r0 *s3.DeleteBucketWebsiteOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) *s3.DeleteBucketWebsiteOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketWebsiteOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketWebsiteInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketWebsite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWebsite'
-type S3API_DeleteBucketWebsite_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketWebsite is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketWebsiteInput
-func (_e *S3API_Expecter) DeleteBucketWebsite(_a0 interface{}) *S3API_DeleteBucketWebsite_Call {
-	return &S3API_DeleteBucketWebsite_Call{Call: _e.mock.On("DeleteBucketWebsite", _a0)}
-}
-
-func (_c *S3API_DeleteBucketWebsite_Call) Run(run func(_a0 *s3.DeleteBucketWebsiteInput)) *S3API_DeleteBucketWebsite_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketWebsiteInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWebsite_Call) Return(_a0 *s3.DeleteBucketWebsiteOutput, _a1 error) *S3API_DeleteBucketWebsite_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWebsite_Call) RunAndReturn(run func(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)) *S3API_DeleteBucketWebsite_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketWebsiteRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteBucketWebsiteRequest(_a0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketWebsiteRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteBucketWebsiteOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteBucketWebsiteInput) *s3.DeleteBucketWebsiteOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteBucketWebsiteOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketWebsiteRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWebsiteRequest'
-type S3API_DeleteBucketWebsiteRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketWebsiteRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteBucketWebsiteInput
-func (_e *S3API_Expecter) DeleteBucketWebsiteRequest(_a0 interface{}) *S3API_DeleteBucketWebsiteRequest_Call {
-	return &S3API_DeleteBucketWebsiteRequest_Call{Call: _e.mock.On("DeleteBucketWebsiteRequest", _a0)}
-}
-
-func (_c *S3API_DeleteBucketWebsiteRequest_Call) Run(run func(_a0 *s3.DeleteBucketWebsiteInput)) *S3API_DeleteBucketWebsiteRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteBucketWebsiteInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWebsiteRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteBucketWebsiteOutput) *S3API_DeleteBucketWebsiteRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWebsiteRequest_Call) RunAndReturn(run func(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)) *S3API_DeleteBucketWebsiteRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketWebsiteWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketWebsiteWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketWebsiteInput, _a2 ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketWebsiteWithContext")
-	}
-
-	var r0 *s3.DeleteBucketWebsiteOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) (*s3.DeleteBucketWebsiteOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) *s3.DeleteBucketWebsiteOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketWebsiteOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketWebsiteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWebsiteWithContext'
-type S3API_DeleteBucketWebsiteWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketWebsiteWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketWebsiteInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketWebsiteWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketWebsiteWithContext_Call {
-	return &S3API_DeleteBucketWebsiteWithContext_Call{Call: _e.mock.On("DeleteBucketWebsiteWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketWebsiteWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketWebsiteInput, _a2 ...request.Option)) *S3API_DeleteBucketWebsiteWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketWebsiteInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWebsiteWithContext_Call) Return(_a0 *s3.DeleteBucketWebsiteOutput, _a1 error) *S3API_DeleteBucketWebsiteWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWebsiteWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) (*s3.DeleteBucketWebsiteOutput, error)) *S3API_DeleteBucketWebsiteWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteBucketWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteBucketWithContext(_a0 aws.Context, _a1 *s3.DeleteBucketInput, _a2 ...request.Option) (*s3.DeleteBucketOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteBucketWithContext")
-	}
-
-	var r0 *s3.DeleteBucketOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInput, ...request.Option) (*s3.DeleteBucketOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInput, ...request.Option) *s3.DeleteBucketOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteBucketOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteBucketWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWithContext'
-type S3API_DeleteBucketWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteBucketWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteBucketInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteBucketWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteBucketWithContext_Call {
-	return &S3API_DeleteBucketWithContext_Call{Call: _e.mock.On("DeleteBucketWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteBucketWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteBucketInput, _a2 ...request.Option)) *S3API_DeleteBucketWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteBucketInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWithContext_Call) Return(_a0 *s3.DeleteBucketOutput, _a1 error) *S3API_DeleteBucketWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteBucketWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteBucketInput, ...request.Option) (*s3.DeleteBucketOutput, error)) *S3API_DeleteBucketWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObject provides a mock function with given fields: _a0
-func (_m *S3API) DeleteObject(_a0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObject")
-	}
-
-	var r0 *s3.DeleteObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) *s3.DeleteObjectOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteObjectInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObject'
-type S3API_DeleteObject_Call struct {
-	*mock.Call
-}
-
-// DeleteObject is a helper method to define mock.On call
-//   - _a0 *s3.DeleteObjectInput
-func (_e *S3API_Expecter) DeleteObject(_a0 interface{}) *S3API_DeleteObject_Call {
-	return &S3API_DeleteObject_Call{Call: _e.mock.On("DeleteObject", _a0)}
-}
-
-func (_c *S3API_DeleteObject_Call) Run(run func(_a0 *s3.DeleteObjectInput)) *S3API_DeleteObject_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObject_Call) Return(_a0 *s3.DeleteObjectOutput, _a1 error) *S3API_DeleteObject_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObject_Call) RunAndReturn(run func(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)) *S3API_DeleteObject_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteObjectRequest(_a0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteObjectOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteObjectInput) *s3.DeleteObjectOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteObjectOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectRequest'
-type S3API_DeleteObjectRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteObjectInput
-func (_e *S3API_Expecter) DeleteObjectRequest(_a0 interface{}) *S3API_DeleteObjectRequest_Call {
-	return &S3API_DeleteObjectRequest_Call{Call: _e.mock.On("DeleteObjectRequest", _a0)}
-}
-
-func (_c *S3API_DeleteObjectRequest_Call) Run(run func(_a0 *s3.DeleteObjectInput)) *S3API_DeleteObjectRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteObjectOutput) *S3API_DeleteObjectRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectRequest_Call) RunAndReturn(run func(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)) *S3API_DeleteObjectRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectTagging provides a mock function with given fields: _a0
-func (_m *S3API) DeleteObjectTagging(_a0 *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectTagging")
-	}
-
-	var r0 *s3.DeleteObjectTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) *s3.DeleteObjectTaggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteObjectTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteObjectTaggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTagging'
-type S3API_DeleteObjectTagging_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectTagging is a helper method to define mock.On call
-//   - _a0 *s3.DeleteObjectTaggingInput
-func (_e *S3API_Expecter) DeleteObjectTagging(_a0 interface{}) *S3API_DeleteObjectTagging_Call {
-	return &S3API_DeleteObjectTagging_Call{Call: _e.mock.On("DeleteObjectTagging", _a0)}
-}
-
-func (_c *S3API_DeleteObjectTagging_Call) Run(run func(_a0 *s3.DeleteObjectTaggingInput)) *S3API_DeleteObjectTagging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteObjectTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectTagging_Call) Return(_a0 *s3.DeleteObjectTaggingOutput, _a1 error) *S3API_DeleteObjectTagging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectTagging_Call) RunAndReturn(run func(*s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error)) *S3API_DeleteObjectTagging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectTaggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteObjectTaggingRequest(_a0 *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectTaggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteObjectTaggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteObjectTaggingInput) *s3.DeleteObjectTaggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteObjectTaggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTaggingRequest'
-type S3API_DeleteObjectTaggingRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectTaggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteObjectTaggingInput
-func (_e *S3API_Expecter) DeleteObjectTaggingRequest(_a0 interface{}) *S3API_DeleteObjectTaggingRequest_Call {
-	return &S3API_DeleteObjectTaggingRequest_Call{Call: _e.mock.On("DeleteObjectTaggingRequest", _a0)}
-}
-
-func (_c *S3API_DeleteObjectTaggingRequest_Call) Run(run func(_a0 *s3.DeleteObjectTaggingInput)) *S3API_DeleteObjectTaggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteObjectTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectTaggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteObjectTaggingOutput) *S3API_DeleteObjectTaggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectTaggingRequest_Call) RunAndReturn(run func(*s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput)) *S3API_DeleteObjectTaggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteObjectTaggingWithContext(_a0 aws.Context, _a1 *s3.DeleteObjectTaggingInput, _a2 ...request.Option) (*s3.DeleteObjectTaggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectTaggingWithContext")
-	}
-
-	var r0 *s3.DeleteObjectTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) (*s3.DeleteObjectTaggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) *s3.DeleteObjectTaggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteObjectTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTaggingWithContext'
-type S3API_DeleteObjectTaggingWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectTaggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteObjectTaggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteObjectTaggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteObjectTaggingWithContext_Call {
-	return &S3API_DeleteObjectTaggingWithContext_Call{Call: _e.mock.On("DeleteObjectTaggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteObjectTaggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteObjectTaggingInput, _a2 ...request.Option)) *S3API_DeleteObjectTaggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteObjectTaggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectTaggingWithContext_Call) Return(_a0 *s3.DeleteObjectTaggingOutput, _a1 error) *S3API_DeleteObjectTaggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectTaggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) (*s3.DeleteObjectTaggingOutput, error)) *S3API_DeleteObjectTaggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteObjectWithContext(_a0 aws.Context, _a1 *s3.DeleteObjectInput, _a2 ...request.Option) (*s3.DeleteObjectOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectWithContext")
-	}
-
-	var r0 *s3.DeleteObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectInput, ...request.Option) (*s3.DeleteObjectOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectInput, ...request.Option) *s3.DeleteObjectOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteObjectInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectWithContext'
-type S3API_DeleteObjectWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteObjectInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteObjectWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteObjectWithContext_Call {
-	return &S3API_DeleteObjectWithContext_Call{Call: _e.mock.On("DeleteObjectWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteObjectWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteObjectInput, _a2 ...request.Option)) *S3API_DeleteObjectWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectWithContext_Call) Return(_a0 *s3.DeleteObjectOutput, _a1 error) *S3API_DeleteObjectWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteObjectInput, ...request.Option) (*s3.DeleteObjectOutput, error)) *S3API_DeleteObjectWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjects provides a mock function with given fields: _a0
-func (_m *S3API) DeleteObjects(_a0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjects")
-	}
-
-	var r0 *s3.DeleteObjectsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) *s3.DeleteObjectsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteObjectsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteObjectsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjects'
-type S3API_DeleteObjects_Call struct {
-	*mock.Call
-}
-
-// DeleteObjects is a helper method to define mock.On call
-//   - _a0 *s3.DeleteObjectsInput
-func (_e *S3API_Expecter) DeleteObjects(_a0 interface{}) *S3API_DeleteObjects_Call {
-	return &S3API_DeleteObjects_Call{Call: _e.mock.On("DeleteObjects", _a0)}
-}
-
-func (_c *S3API_DeleteObjects_Call) Run(run func(_a0 *s3.DeleteObjectsInput)) *S3API_DeleteObjects_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteObjectsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjects_Call) Return(_a0 *s3.DeleteObjectsOutput, _a1 error) *S3API_DeleteObjects_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjects_Call) RunAndReturn(run func(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)) *S3API_DeleteObjects_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectsRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeleteObjectsRequest(_a0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeleteObjectsOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeleteObjectsInput) *s3.DeleteObjectsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeleteObjectsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectsRequest'
-type S3API_DeleteObjectsRequest_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectsRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeleteObjectsInput
-func (_e *S3API_Expecter) DeleteObjectsRequest(_a0 interface{}) *S3API_DeleteObjectsRequest_Call {
-	return &S3API_DeleteObjectsRequest_Call{Call: _e.mock.On("DeleteObjectsRequest", _a0)}
-}
-
-func (_c *S3API_DeleteObjectsRequest_Call) Run(run func(_a0 *s3.DeleteObjectsInput)) *S3API_DeleteObjectsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeleteObjectsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectsRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeleteObjectsOutput) *S3API_DeleteObjectsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectsRequest_Call) RunAndReturn(run func(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)) *S3API_DeleteObjectsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteObjectsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeleteObjectsWithContext(_a0 aws.Context, _a1 *s3.DeleteObjectsInput, _a2 ...request.Option) (*s3.DeleteObjectsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteObjectsWithContext")
-	}
-
-	var r0 *s3.DeleteObjectsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) (*s3.DeleteObjectsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) *s3.DeleteObjectsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeleteObjectsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeleteObjectsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectsWithContext'
-type S3API_DeleteObjectsWithContext_Call struct {
-	*mock.Call
-}
-
-// DeleteObjectsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeleteObjectsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeleteObjectsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeleteObjectsWithContext_Call {
-	return &S3API_DeleteObjectsWithContext_Call{Call: _e.mock.On("DeleteObjectsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeleteObjectsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeleteObjectsInput, _a2 ...request.Option)) *S3API_DeleteObjectsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeleteObjectsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeleteObjectsWithContext_Call) Return(_a0 *s3.DeleteObjectsOutput, _a1 error) *S3API_DeleteObjectsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeleteObjectsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) (*s3.DeleteObjectsOutput, error)) *S3API_DeleteObjectsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeletePublicAccessBlock provides a mock function with given fields: _a0
-func (_m *S3API) DeletePublicAccessBlock(_a0 *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeletePublicAccessBlock")
-	}
-
-	var r0 *s3.DeletePublicAccessBlockOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) *s3.DeletePublicAccessBlockOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeletePublicAccessBlockOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeletePublicAccessBlockInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeletePublicAccessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicAccessBlock'
-type S3API_DeletePublicAccessBlock_Call struct {
-	*mock.Call
-}
-
-// DeletePublicAccessBlock is a helper method to define mock.On call
-//   - _a0 *s3.DeletePublicAccessBlockInput
-func (_e *S3API_Expecter) DeletePublicAccessBlock(_a0 interface{}) *S3API_DeletePublicAccessBlock_Call {
-	return &S3API_DeletePublicAccessBlock_Call{Call: _e.mock.On("DeletePublicAccessBlock", _a0)}
-}
-
-func (_c *S3API_DeletePublicAccessBlock_Call) Run(run func(_a0 *s3.DeletePublicAccessBlockInput)) *S3API_DeletePublicAccessBlock_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeletePublicAccessBlockInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeletePublicAccessBlock_Call) Return(_a0 *s3.DeletePublicAccessBlockOutput, _a1 error) *S3API_DeletePublicAccessBlock_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeletePublicAccessBlock_Call) RunAndReturn(run func(*s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error)) *S3API_DeletePublicAccessBlock_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeletePublicAccessBlockRequest provides a mock function with given fields: _a0
-func (_m *S3API) DeletePublicAccessBlockRequest(_a0 *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeletePublicAccessBlockRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.DeletePublicAccessBlockOutput
-	if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.DeletePublicAccessBlockInput) *s3.DeletePublicAccessBlockOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.DeletePublicAccessBlockOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_DeletePublicAccessBlockRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicAccessBlockRequest'
-type S3API_DeletePublicAccessBlockRequest_Call struct {
-	*mock.Call
-}
-
-// DeletePublicAccessBlockRequest is a helper method to define mock.On call
-//   - _a0 *s3.DeletePublicAccessBlockInput
-func (_e *S3API_Expecter) DeletePublicAccessBlockRequest(_a0 interface{}) *S3API_DeletePublicAccessBlockRequest_Call {
-	return &S3API_DeletePublicAccessBlockRequest_Call{Call: _e.mock.On("DeletePublicAccessBlockRequest", _a0)}
-}
-
-func (_c *S3API_DeletePublicAccessBlockRequest_Call) Run(run func(_a0 *s3.DeletePublicAccessBlockInput)) *S3API_DeletePublicAccessBlockRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.DeletePublicAccessBlockInput))
-	})
-	return _c
-}
-
-func (_c *S3API_DeletePublicAccessBlockRequest_Call) Return(_a0 *request.Request, _a1 *s3.DeletePublicAccessBlockOutput) *S3API_DeletePublicAccessBlockRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeletePublicAccessBlockRequest_Call) RunAndReturn(run func(*s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput)) *S3API_DeletePublicAccessBlockRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeletePublicAccessBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) DeletePublicAccessBlockWithContext(_a0 aws.Context, _a1 *s3.DeletePublicAccessBlockInput, _a2 ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeletePublicAccessBlockWithContext")
-	}
-
-	var r0 *s3.DeletePublicAccessBlockOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) (*s3.DeletePublicAccessBlockOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) *s3.DeletePublicAccessBlockOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.DeletePublicAccessBlockOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_DeletePublicAccessBlockWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicAccessBlockWithContext'
-type S3API_DeletePublicAccessBlockWithContext_Call struct {
-	*mock.Call
-}
-
-// DeletePublicAccessBlockWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.DeletePublicAccessBlockInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) DeletePublicAccessBlockWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_DeletePublicAccessBlockWithContext_Call {
-	return &S3API_DeletePublicAccessBlockWithContext_Call{Call: _e.mock.On("DeletePublicAccessBlockWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_DeletePublicAccessBlockWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.DeletePublicAccessBlockInput, _a2 ...request.Option)) *S3API_DeletePublicAccessBlockWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.DeletePublicAccessBlockInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_DeletePublicAccessBlockWithContext_Call) Return(_a0 *s3.DeletePublicAccessBlockOutput, _a1 error) *S3API_DeletePublicAccessBlockWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_DeletePublicAccessBlockWithContext_Call) RunAndReturn(run func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) (*s3.DeletePublicAccessBlockOutput, error)) *S3API_DeletePublicAccessBlockWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAccelerateConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketAccelerateConfiguration(_a0 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAccelerateConfiguration")
-	}
-
-	var r0 *s3.GetBucketAccelerateConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) *s3.GetBucketAccelerateConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketAccelerateConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketAccelerateConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAccelerateConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAccelerateConfiguration'
-type S3API_GetBucketAccelerateConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketAccelerateConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketAccelerateConfigurationInput
-func (_e *S3API_Expecter) GetBucketAccelerateConfiguration(_a0 interface{}) *S3API_GetBucketAccelerateConfiguration_Call {
-	return &S3API_GetBucketAccelerateConfiguration_Call{Call: _e.mock.On("GetBucketAccelerateConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketAccelerateConfiguration_Call) Run(run func(_a0 *s3.GetBucketAccelerateConfigurationInput)) *S3API_GetBucketAccelerateConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketAccelerateConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAccelerateConfiguration_Call) Return(_a0 *s3.GetBucketAccelerateConfigurationOutput, _a1 error) *S3API_GetBucketAccelerateConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAccelerateConfiguration_Call) RunAndReturn(run func(*s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error)) *S3API_GetBucketAccelerateConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAccelerateConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketAccelerateConfigurationRequest(_a0 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAccelerateConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketAccelerateConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketAccelerateConfigurationInput) *s3.GetBucketAccelerateConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketAccelerateConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAccelerateConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAccelerateConfigurationRequest'
-type S3API_GetBucketAccelerateConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketAccelerateConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketAccelerateConfigurationInput
-func (_e *S3API_Expecter) GetBucketAccelerateConfigurationRequest(_a0 interface{}) *S3API_GetBucketAccelerateConfigurationRequest_Call {
-	return &S3API_GetBucketAccelerateConfigurationRequest_Call{Call: _e.mock.On("GetBucketAccelerateConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketAccelerateConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketAccelerateConfigurationInput)) *S3API_GetBucketAccelerateConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketAccelerateConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAccelerateConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketAccelerateConfigurationOutput) *S3API_GetBucketAccelerateConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAccelerateConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput)) *S3API_GetBucketAccelerateConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAccelerateConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketAccelerateConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketAccelerateConfigurationInput, _a2 ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAccelerateConfigurationWithContext")
-	}
-
-	var r0 *s3.GetBucketAccelerateConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) *s3.GetBucketAccelerateConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketAccelerateConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAccelerateConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAccelerateConfigurationWithContext'
-type S3API_GetBucketAccelerateConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketAccelerateConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketAccelerateConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketAccelerateConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketAccelerateConfigurationWithContext_Call {
-	return &S3API_GetBucketAccelerateConfigurationWithContext_Call{Call: _e.mock.On("GetBucketAccelerateConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketAccelerateConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketAccelerateConfigurationInput, _a2 ...request.Option)) *S3API_GetBucketAccelerateConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketAccelerateConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAccelerateConfigurationWithContext_Call) Return(_a0 *s3.GetBucketAccelerateConfigurationOutput, _a1 error) *S3API_GetBucketAccelerateConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAccelerateConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error)) *S3API_GetBucketAccelerateConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAcl provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketAcl(_a0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAcl")
-	}
-
-	var r0 *s3.GetBucketAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) *s3.GetBucketAclOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketAclInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAcl'
-type S3API_GetBucketAcl_Call struct {
-	*mock.Call
-}
-
-// GetBucketAcl is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketAclInput
-func (_e *S3API_Expecter) GetBucketAcl(_a0 interface{}) *S3API_GetBucketAcl_Call {
-	return &S3API_GetBucketAcl_Call{Call: _e.mock.On("GetBucketAcl", _a0)}
-}
-
-func (_c *S3API_GetBucketAcl_Call) Run(run func(_a0 *s3.GetBucketAclInput)) *S3API_GetBucketAcl_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAcl_Call) Return(_a0 *s3.GetBucketAclOutput, _a1 error) *S3API_GetBucketAcl_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAcl_Call) RunAndReturn(run func(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)) *S3API_GetBucketAcl_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAclRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketAclRequest(_a0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAclRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketAclOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketAclInput) *s3.GetBucketAclOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketAclOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAclRequest'
-type S3API_GetBucketAclRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketAclRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketAclInput
-func (_e *S3API_Expecter) GetBucketAclRequest(_a0 interface{}) *S3API_GetBucketAclRequest_Call {
-	return &S3API_GetBucketAclRequest_Call{Call: _e.mock.On("GetBucketAclRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketAclRequest_Call) Run(run func(_a0 *s3.GetBucketAclInput)) *S3API_GetBucketAclRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAclRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketAclOutput) *S3API_GetBucketAclRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAclRequest_Call) RunAndReturn(run func(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)) *S3API_GetBucketAclRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAclWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketAclWithContext(_a0 aws.Context, _a1 *s3.GetBucketAclInput, _a2 ...request.Option) (*s3.GetBucketAclOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAclWithContext")
-	}
-
-	var r0 *s3.GetBucketAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAclInput, ...request.Option) (*s3.GetBucketAclOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAclInput, ...request.Option) *s3.GetBucketAclOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketAclInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAclWithContext'
-type S3API_GetBucketAclWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketAclWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketAclInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketAclWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketAclWithContext_Call {
-	return &S3API_GetBucketAclWithContext_Call{Call: _e.mock.On("GetBucketAclWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketAclWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketAclInput, _a2 ...request.Option)) *S3API_GetBucketAclWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketAclInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAclWithContext_Call) Return(_a0 *s3.GetBucketAclOutput, _a1 error) *S3API_GetBucketAclWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAclWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketAclInput, ...request.Option) (*s3.GetBucketAclOutput, error)) *S3API_GetBucketAclWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAnalyticsConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketAnalyticsConfiguration(_a0 *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAnalyticsConfiguration")
-	}
-
-	var r0 *s3.GetBucketAnalyticsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) *s3.GetBucketAnalyticsConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketAnalyticsConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAnalyticsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAnalyticsConfiguration'
-type S3API_GetBucketAnalyticsConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketAnalyticsConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketAnalyticsConfigurationInput
-func (_e *S3API_Expecter) GetBucketAnalyticsConfiguration(_a0 interface{}) *S3API_GetBucketAnalyticsConfiguration_Call {
-	return &S3API_GetBucketAnalyticsConfiguration_Call{Call: _e.mock.On("GetBucketAnalyticsConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketAnalyticsConfiguration_Call) Run(run func(_a0 *s3.GetBucketAnalyticsConfigurationInput)) *S3API_GetBucketAnalyticsConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketAnalyticsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAnalyticsConfiguration_Call) Return(_a0 *s3.GetBucketAnalyticsConfigurationOutput, _a1 error) *S3API_GetBucketAnalyticsConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAnalyticsConfiguration_Call) RunAndReturn(run func(*s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error)) *S3API_GetBucketAnalyticsConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAnalyticsConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketAnalyticsConfigurationRequest(_a0 *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAnalyticsConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketAnalyticsConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketAnalyticsConfigurationInput) *s3.GetBucketAnalyticsConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAnalyticsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAnalyticsConfigurationRequest'
-type S3API_GetBucketAnalyticsConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketAnalyticsConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketAnalyticsConfigurationInput
-func (_e *S3API_Expecter) GetBucketAnalyticsConfigurationRequest(_a0 interface{}) *S3API_GetBucketAnalyticsConfigurationRequest_Call {
-	return &S3API_GetBucketAnalyticsConfigurationRequest_Call{Call: _e.mock.On("GetBucketAnalyticsConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketAnalyticsConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketAnalyticsConfigurationInput)) *S3API_GetBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketAnalyticsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAnalyticsConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketAnalyticsConfigurationOutput) *S3API_GetBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAnalyticsConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput)) *S3API_GetBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketAnalyticsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketAnalyticsConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketAnalyticsConfigurationInput, _a2 ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketAnalyticsConfigurationWithContext")
-	}
-
-	var r0 *s3.GetBucketAnalyticsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) *s3.GetBucketAnalyticsConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketAnalyticsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAnalyticsConfigurationWithContext'
-type S3API_GetBucketAnalyticsConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketAnalyticsConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketAnalyticsConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketAnalyticsConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketAnalyticsConfigurationWithContext_Call {
-	return &S3API_GetBucketAnalyticsConfigurationWithContext_Call{Call: _e.mock.On("GetBucketAnalyticsConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketAnalyticsConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketAnalyticsConfigurationInput, _a2 ...request.Option)) *S3API_GetBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketAnalyticsConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketAnalyticsConfigurationWithContext_Call) Return(_a0 *s3.GetBucketAnalyticsConfigurationOutput, _a1 error) *S3API_GetBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketAnalyticsConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error)) *S3API_GetBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketCors provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketCors(_a0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketCors")
-	}
-
-	var r0 *s3.GetBucketCorsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) *s3.GetBucketCorsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketCorsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketCorsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketCors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketCors'
-type S3API_GetBucketCors_Call struct {
-	*mock.Call
-}
-
-// GetBucketCors is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketCorsInput
-func (_e *S3API_Expecter) GetBucketCors(_a0 interface{}) *S3API_GetBucketCors_Call {
-	return &S3API_GetBucketCors_Call{Call: _e.mock.On("GetBucketCors", _a0)}
-}
-
-func (_c *S3API_GetBucketCors_Call) Run(run func(_a0 *s3.GetBucketCorsInput)) *S3API_GetBucketCors_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketCorsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketCors_Call) Return(_a0 *s3.GetBucketCorsOutput, _a1 error) *S3API_GetBucketCors_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketCors_Call) RunAndReturn(run func(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)) *S3API_GetBucketCors_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketCorsRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketCorsRequest(_a0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketCorsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketCorsOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketCorsInput) *s3.GetBucketCorsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketCorsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketCorsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketCorsRequest'
-type S3API_GetBucketCorsRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketCorsRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketCorsInput
-func (_e *S3API_Expecter) GetBucketCorsRequest(_a0 interface{}) *S3API_GetBucketCorsRequest_Call {
-	return &S3API_GetBucketCorsRequest_Call{Call: _e.mock.On("GetBucketCorsRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketCorsRequest_Call) Run(run func(_a0 *s3.GetBucketCorsInput)) *S3API_GetBucketCorsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketCorsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketCorsRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketCorsOutput) *S3API_GetBucketCorsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketCorsRequest_Call) RunAndReturn(run func(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)) *S3API_GetBucketCorsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketCorsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketCorsWithContext(_a0 aws.Context, _a1 *s3.GetBucketCorsInput, _a2 ...request.Option) (*s3.GetBucketCorsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketCorsWithContext")
-	}
-
-	var r0 *s3.GetBucketCorsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) *s3.GetBucketCorsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketCorsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketCorsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketCorsWithContext'
-type S3API_GetBucketCorsWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketCorsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketCorsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketCorsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketCorsWithContext_Call {
-	return &S3API_GetBucketCorsWithContext_Call{Call: _e.mock.On("GetBucketCorsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketCorsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketCorsInput, _a2 ...request.Option)) *S3API_GetBucketCorsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketCorsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketCorsWithContext_Call) Return(_a0 *s3.GetBucketCorsOutput, _a1 error) *S3API_GetBucketCorsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketCorsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error)) *S3API_GetBucketCorsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketEncryption provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketEncryption(_a0 *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketEncryption")
-	}
-
-	var r0 *s3.GetBucketEncryptionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) *s3.GetBucketEncryptionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketEncryptionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketEncryptionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketEncryption'
-type S3API_GetBucketEncryption_Call struct {
-	*mock.Call
-}
-
-// GetBucketEncryption is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketEncryptionInput
-func (_e *S3API_Expecter) GetBucketEncryption(_a0 interface{}) *S3API_GetBucketEncryption_Call {
-	return &S3API_GetBucketEncryption_Call{Call: _e.mock.On("GetBucketEncryption", _a0)}
-}
-
-func (_c *S3API_GetBucketEncryption_Call) Run(run func(_a0 *s3.GetBucketEncryptionInput)) *S3API_GetBucketEncryption_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketEncryptionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketEncryption_Call) Return(_a0 *s3.GetBucketEncryptionOutput, _a1 error) *S3API_GetBucketEncryption_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketEncryption_Call) RunAndReturn(run func(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)) *S3API_GetBucketEncryption_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketEncryptionRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketEncryptionRequest(_a0 *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketEncryptionRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketEncryptionOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketEncryptionInput) *s3.GetBucketEncryptionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketEncryptionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketEncryptionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketEncryptionRequest'
-type S3API_GetBucketEncryptionRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketEncryptionRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketEncryptionInput
-func (_e *S3API_Expecter) GetBucketEncryptionRequest(_a0 interface{}) *S3API_GetBucketEncryptionRequest_Call {
-	return &S3API_GetBucketEncryptionRequest_Call{Call: _e.mock.On("GetBucketEncryptionRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketEncryptionRequest_Call) Run(run func(_a0 *s3.GetBucketEncryptionInput)) *S3API_GetBucketEncryptionRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketEncryptionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketEncryptionRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketEncryptionOutput) *S3API_GetBucketEncryptionRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketEncryptionRequest_Call) RunAndReturn(run func(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)) *S3API_GetBucketEncryptionRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketEncryptionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketEncryptionWithContext(_a0 aws.Context, _a1 *s3.GetBucketEncryptionInput, _a2 ...request.Option) (*s3.GetBucketEncryptionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketEncryptionWithContext")
-	}
-
-	var r0 *s3.GetBucketEncryptionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) *s3.GetBucketEncryptionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketEncryptionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketEncryptionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketEncryptionWithContext'
-type S3API_GetBucketEncryptionWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketEncryptionWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketEncryptionInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketEncryptionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketEncryptionWithContext_Call {
-	return &S3API_GetBucketEncryptionWithContext_Call{Call: _e.mock.On("GetBucketEncryptionWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketEncryptionWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketEncryptionInput, _a2 ...request.Option)) *S3API_GetBucketEncryptionWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketEncryptionInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketEncryptionWithContext_Call) Return(_a0 *s3.GetBucketEncryptionOutput, _a1 error) *S3API_GetBucketEncryptionWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketEncryptionWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error)) *S3API_GetBucketEncryptionWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketIntelligentTieringConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketIntelligentTieringConfiguration(_a0 *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketIntelligentTieringConfiguration")
-	}
-
-	var r0 *s3.GetBucketIntelligentTieringConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *s3.GetBucketIntelligentTieringConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketIntelligentTieringConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketIntelligentTieringConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketIntelligentTieringConfiguration'
-type S3API_GetBucketIntelligentTieringConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketIntelligentTieringConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketIntelligentTieringConfigurationInput
-func (_e *S3API_Expecter) GetBucketIntelligentTieringConfiguration(_a0 interface{}) *S3API_GetBucketIntelligentTieringConfiguration_Call {
-	return &S3API_GetBucketIntelligentTieringConfiguration_Call{Call: _e.mock.On("GetBucketIntelligentTieringConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfiguration_Call) Run(run func(_a0 *s3.GetBucketIntelligentTieringConfigurationInput)) *S3API_GetBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketIntelligentTieringConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfiguration_Call) Return(_a0 *s3.GetBucketIntelligentTieringConfigurationOutput, _a1 error) *S3API_GetBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfiguration_Call) RunAndReturn(run func(*s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)) *S3API_GetBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketIntelligentTieringConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketIntelligentTieringConfigurationRequest(_a0 *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketIntelligentTieringConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketIntelligentTieringConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *s3.GetBucketIntelligentTieringConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketIntelligentTieringConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketIntelligentTieringConfigurationRequest'
-type S3API_GetBucketIntelligentTieringConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketIntelligentTieringConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketIntelligentTieringConfigurationInput
-func (_e *S3API_Expecter) GetBucketIntelligentTieringConfigurationRequest(_a0 interface{}) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call {
-	return &S3API_GetBucketIntelligentTieringConfigurationRequest_Call{Call: _e.mock.On("GetBucketIntelligentTieringConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketIntelligentTieringConfigurationInput)) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketIntelligentTieringConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketIntelligentTieringConfigurationOutput) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput)) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketIntelligentTieringConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketIntelligentTieringConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketIntelligentTieringConfigurationInput, _a2 ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketIntelligentTieringConfigurationWithContext")
-	}
-
-	var r0 *s3.GetBucketIntelligentTieringConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.GetBucketIntelligentTieringConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketIntelligentTieringConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketIntelligentTieringConfigurationWithContext'
-type S3API_GetBucketIntelligentTieringConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketIntelligentTieringConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketIntelligentTieringConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketIntelligentTieringConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call {
-	return &S3API_GetBucketIntelligentTieringConfigurationWithContext_Call{Call: _e.mock.On("GetBucketIntelligentTieringConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketIntelligentTieringConfigurationInput, _a2 ...request.Option)) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketIntelligentTieringConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call) Return(_a0 *s3.GetBucketIntelligentTieringConfigurationOutput, _a1 error) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketInventoryConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketInventoryConfiguration(_a0 *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketInventoryConfiguration")
-	}
-
-	var r0 *s3.GetBucketInventoryConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) *s3.GetBucketInventoryConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketInventoryConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketInventoryConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketInventoryConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketInventoryConfiguration'
-type S3API_GetBucketInventoryConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketInventoryConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketInventoryConfigurationInput
-func (_e *S3API_Expecter) GetBucketInventoryConfiguration(_a0 interface{}) *S3API_GetBucketInventoryConfiguration_Call {
-	return &S3API_GetBucketInventoryConfiguration_Call{Call: _e.mock.On("GetBucketInventoryConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketInventoryConfiguration_Call) Run(run func(_a0 *s3.GetBucketInventoryConfigurationInput)) *S3API_GetBucketInventoryConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketInventoryConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketInventoryConfiguration_Call) Return(_a0 *s3.GetBucketInventoryConfigurationOutput, _a1 error) *S3API_GetBucketInventoryConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketInventoryConfiguration_Call) RunAndReturn(run func(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)) *S3API_GetBucketInventoryConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketInventoryConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketInventoryConfigurationRequest(_a0 *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketInventoryConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketInventoryConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketInventoryConfigurationInput) *s3.GetBucketInventoryConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketInventoryConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketInventoryConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketInventoryConfigurationRequest'
-type S3API_GetBucketInventoryConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketInventoryConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketInventoryConfigurationInput
-func (_e *S3API_Expecter) GetBucketInventoryConfigurationRequest(_a0 interface{}) *S3API_GetBucketInventoryConfigurationRequest_Call {
-	return &S3API_GetBucketInventoryConfigurationRequest_Call{Call: _e.mock.On("GetBucketInventoryConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketInventoryConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketInventoryConfigurationInput)) *S3API_GetBucketInventoryConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketInventoryConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketInventoryConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketInventoryConfigurationOutput) *S3API_GetBucketInventoryConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketInventoryConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)) *S3API_GetBucketInventoryConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketInventoryConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketInventoryConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketInventoryConfigurationInput, _a2 ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketInventoryConfigurationWithContext")
-	}
-
-	var r0 *s3.GetBucketInventoryConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) *s3.GetBucketInventoryConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketInventoryConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketInventoryConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketInventoryConfigurationWithContext'
-type S3API_GetBucketInventoryConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketInventoryConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketInventoryConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketInventoryConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketInventoryConfigurationWithContext_Call {
-	return &S3API_GetBucketInventoryConfigurationWithContext_Call{Call: _e.mock.On("GetBucketInventoryConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketInventoryConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketInventoryConfigurationInput, _a2 ...request.Option)) *S3API_GetBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketInventoryConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketInventoryConfigurationWithContext_Call) Return(_a0 *s3.GetBucketInventoryConfigurationOutput, _a1 error) *S3API_GetBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketInventoryConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)) *S3API_GetBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLifecycle provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLifecycle(_a0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLifecycle")
-	}
-
-	var r0 *s3.GetBucketLifecycleOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) *s3.GetBucketLifecycleOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLifecycleOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycle'
-type S3API_GetBucketLifecycle_Call struct {
-	*mock.Call
-}
-
-// GetBucketLifecycle is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLifecycleInput
-func (_e *S3API_Expecter) GetBucketLifecycle(_a0 interface{}) *S3API_GetBucketLifecycle_Call {
-	return &S3API_GetBucketLifecycle_Call{Call: _e.mock.On("GetBucketLifecycle", _a0)}
-}
-
-func (_c *S3API_GetBucketLifecycle_Call) Run(run func(_a0 *s3.GetBucketLifecycleInput)) *S3API_GetBucketLifecycle_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLifecycleInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycle_Call) Return(_a0 *s3.GetBucketLifecycleOutput, _a1 error) *S3API_GetBucketLifecycle_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycle_Call) RunAndReturn(run func(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)) *S3API_GetBucketLifecycle_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLifecycleConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLifecycleConfiguration(_a0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLifecycleConfiguration")
-	}
-
-	var r0 *s3.GetBucketLifecycleConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) *s3.GetBucketLifecycleConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLifecycleConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLifecycleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfiguration'
-type S3API_GetBucketLifecycleConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketLifecycleConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLifecycleConfigurationInput
-func (_e *S3API_Expecter) GetBucketLifecycleConfiguration(_a0 interface{}) *S3API_GetBucketLifecycleConfiguration_Call {
-	return &S3API_GetBucketLifecycleConfiguration_Call{Call: _e.mock.On("GetBucketLifecycleConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketLifecycleConfiguration_Call) Run(run func(_a0 *s3.GetBucketLifecycleConfigurationInput)) *S3API_GetBucketLifecycleConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLifecycleConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleConfiguration_Call) Return(_a0 *s3.GetBucketLifecycleConfigurationOutput, _a1 error) *S3API_GetBucketLifecycleConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleConfiguration_Call) RunAndReturn(run func(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)) *S3API_GetBucketLifecycleConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLifecycleConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLifecycleConfigurationRequest(_a0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLifecycleConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketLifecycleConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleConfigurationInput) *s3.GetBucketLifecycleConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketLifecycleConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLifecycleConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfigurationRequest'
-type S3API_GetBucketLifecycleConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketLifecycleConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLifecycleConfigurationInput
-func (_e *S3API_Expecter) GetBucketLifecycleConfigurationRequest(_a0 interface{}) *S3API_GetBucketLifecycleConfigurationRequest_Call {
-	return &S3API_GetBucketLifecycleConfigurationRequest_Call{Call: _e.mock.On("GetBucketLifecycleConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketLifecycleConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketLifecycleConfigurationInput)) *S3API_GetBucketLifecycleConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLifecycleConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketLifecycleConfigurationOutput) *S3API_GetBucketLifecycleConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)) *S3API_GetBucketLifecycleConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLifecycleConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketLifecycleConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketLifecycleConfigurationInput, _a2 ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLifecycleConfigurationWithContext")
-	}
-
-	var r0 *s3.GetBucketLifecycleConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) *s3.GetBucketLifecycleConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLifecycleConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLifecycleConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfigurationWithContext'
-type S3API_GetBucketLifecycleConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketLifecycleConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketLifecycleConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketLifecycleConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketLifecycleConfigurationWithContext_Call {
-	return &S3API_GetBucketLifecycleConfigurationWithContext_Call{Call: _e.mock.On("GetBucketLifecycleConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketLifecycleConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketLifecycleConfigurationInput, _a2 ...request.Option)) *S3API_GetBucketLifecycleConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketLifecycleConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleConfigurationWithContext_Call) Return(_a0 *s3.GetBucketLifecycleConfigurationOutput, _a1 error) *S3API_GetBucketLifecycleConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error)) *S3API_GetBucketLifecycleConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLifecycleRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLifecycleRequest(_a0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLifecycleRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketLifecycleOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleInput) *s3.GetBucketLifecycleOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketLifecycleOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLifecycleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleRequest'
-type S3API_GetBucketLifecycleRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketLifecycleRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLifecycleInput
-func (_e *S3API_Expecter) GetBucketLifecycleRequest(_a0 interface{}) *S3API_GetBucketLifecycleRequest_Call {
-	return &S3API_GetBucketLifecycleRequest_Call{Call: _e.mock.On("GetBucketLifecycleRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketLifecycleRequest_Call) Run(run func(_a0 *s3.GetBucketLifecycleInput)) *S3API_GetBucketLifecycleRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLifecycleInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketLifecycleOutput) *S3API_GetBucketLifecycleRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleRequest_Call) RunAndReturn(run func(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)) *S3API_GetBucketLifecycleRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLifecycleWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketLifecycleWithContext(_a0 aws.Context, _a1 *s3.GetBucketLifecycleInput, _a2 ...request.Option) (*s3.GetBucketLifecycleOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLifecycleWithContext")
-	}
-
-	var r0 *s3.GetBucketLifecycleOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) (*s3.GetBucketLifecycleOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) *s3.GetBucketLifecycleOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLifecycleOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLifecycleWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleWithContext'
-type S3API_GetBucketLifecycleWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketLifecycleWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketLifecycleInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketLifecycleWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketLifecycleWithContext_Call {
-	return &S3API_GetBucketLifecycleWithContext_Call{Call: _e.mock.On("GetBucketLifecycleWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketLifecycleWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketLifecycleInput, _a2 ...request.Option)) *S3API_GetBucketLifecycleWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketLifecycleInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleWithContext_Call) Return(_a0 *s3.GetBucketLifecycleOutput, _a1 error) *S3API_GetBucketLifecycleWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLifecycleWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) (*s3.GetBucketLifecycleOutput, error)) *S3API_GetBucketLifecycleWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLocation provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLocation(_a0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLocation")
-	}
-
-	var r0 *s3.GetBucketLocationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) *s3.GetBucketLocationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLocationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLocationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLocation'
-type S3API_GetBucketLocation_Call struct {
-	*mock.Call
-}
-
-// GetBucketLocation is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLocationInput
-func (_e *S3API_Expecter) GetBucketLocation(_a0 interface{}) *S3API_GetBucketLocation_Call {
-	return &S3API_GetBucketLocation_Call{Call: _e.mock.On("GetBucketLocation", _a0)}
-}
-
-func (_c *S3API_GetBucketLocation_Call) Run(run func(_a0 *s3.GetBucketLocationInput)) *S3API_GetBucketLocation_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLocationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLocation_Call) Return(_a0 *s3.GetBucketLocationOutput, _a1 error) *S3API_GetBucketLocation_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLocation_Call) RunAndReturn(run func(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)) *S3API_GetBucketLocation_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLocationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLocationRequest(_a0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLocationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketLocationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLocationInput) *s3.GetBucketLocationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketLocationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLocationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLocationRequest'
-type S3API_GetBucketLocationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketLocationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLocationInput
-func (_e *S3API_Expecter) GetBucketLocationRequest(_a0 interface{}) *S3API_GetBucketLocationRequest_Call {
-	return &S3API_GetBucketLocationRequest_Call{Call: _e.mock.On("GetBucketLocationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketLocationRequest_Call) Run(run func(_a0 *s3.GetBucketLocationInput)) *S3API_GetBucketLocationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLocationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLocationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketLocationOutput) *S3API_GetBucketLocationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLocationRequest_Call) RunAndReturn(run func(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)) *S3API_GetBucketLocationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLocationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketLocationWithContext(_a0 aws.Context, _a1 *s3.GetBucketLocationInput, _a2 ...request.Option) (*s3.GetBucketLocationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLocationWithContext")
-	}
-
-	var r0 *s3.GetBucketLocationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) (*s3.GetBucketLocationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) *s3.GetBucketLocationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLocationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLocationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLocationWithContext'
-type S3API_GetBucketLocationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketLocationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketLocationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketLocationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketLocationWithContext_Call {
-	return &S3API_GetBucketLocationWithContext_Call{Call: _e.mock.On("GetBucketLocationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketLocationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketLocationInput, _a2 ...request.Option)) *S3API_GetBucketLocationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketLocationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLocationWithContext_Call) Return(_a0 *s3.GetBucketLocationOutput, _a1 error) *S3API_GetBucketLocationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLocationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) (*s3.GetBucketLocationOutput, error)) *S3API_GetBucketLocationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLogging provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLogging(_a0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLogging")
-	}
-
-	var r0 *s3.GetBucketLoggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) *s3.GetBucketLoggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLoggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLoggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLogging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLogging'
-type S3API_GetBucketLogging_Call struct {
-	*mock.Call
-}
-
-// GetBucketLogging is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLoggingInput
-func (_e *S3API_Expecter) GetBucketLogging(_a0 interface{}) *S3API_GetBucketLogging_Call {
-	return &S3API_GetBucketLogging_Call{Call: _e.mock.On("GetBucketLogging", _a0)}
-}
-
-func (_c *S3API_GetBucketLogging_Call) Run(run func(_a0 *s3.GetBucketLoggingInput)) *S3API_GetBucketLogging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLoggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLogging_Call) Return(_a0 *s3.GetBucketLoggingOutput, _a1 error) *S3API_GetBucketLogging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLogging_Call) RunAndReturn(run func(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)) *S3API_GetBucketLogging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLoggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketLoggingRequest(_a0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLoggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketLoggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketLoggingInput) *s3.GetBucketLoggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketLoggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLoggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLoggingRequest'
-type S3API_GetBucketLoggingRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketLoggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketLoggingInput
-func (_e *S3API_Expecter) GetBucketLoggingRequest(_a0 interface{}) *S3API_GetBucketLoggingRequest_Call {
-	return &S3API_GetBucketLoggingRequest_Call{Call: _e.mock.On("GetBucketLoggingRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketLoggingRequest_Call) Run(run func(_a0 *s3.GetBucketLoggingInput)) *S3API_GetBucketLoggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketLoggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLoggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketLoggingOutput) *S3API_GetBucketLoggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLoggingRequest_Call) RunAndReturn(run func(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)) *S3API_GetBucketLoggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketLoggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketLoggingWithContext(_a0 aws.Context, _a1 *s3.GetBucketLoggingInput, _a2 ...request.Option) (*s3.GetBucketLoggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketLoggingWithContext")
-	}
-
-	var r0 *s3.GetBucketLoggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) (*s3.GetBucketLoggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) *s3.GetBucketLoggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketLoggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketLoggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLoggingWithContext'
-type S3API_GetBucketLoggingWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketLoggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketLoggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketLoggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketLoggingWithContext_Call {
-	return &S3API_GetBucketLoggingWithContext_Call{Call: _e.mock.On("GetBucketLoggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketLoggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketLoggingInput, _a2 ...request.Option)) *S3API_GetBucketLoggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketLoggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketLoggingWithContext_Call) Return(_a0 *s3.GetBucketLoggingOutput, _a1 error) *S3API_GetBucketLoggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketLoggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) (*s3.GetBucketLoggingOutput, error)) *S3API_GetBucketLoggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketMetricsConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketMetricsConfiguration(_a0 *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketMetricsConfiguration")
-	}
-
-	var r0 *s3.GetBucketMetricsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) *s3.GetBucketMetricsConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketMetricsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketMetricsConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketMetricsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketMetricsConfiguration'
-type S3API_GetBucketMetricsConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketMetricsConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketMetricsConfigurationInput
-func (_e *S3API_Expecter) GetBucketMetricsConfiguration(_a0 interface{}) *S3API_GetBucketMetricsConfiguration_Call {
-	return &S3API_GetBucketMetricsConfiguration_Call{Call: _e.mock.On("GetBucketMetricsConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketMetricsConfiguration_Call) Run(run func(_a0 *s3.GetBucketMetricsConfigurationInput)) *S3API_GetBucketMetricsConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketMetricsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketMetricsConfiguration_Call) Return(_a0 *s3.GetBucketMetricsConfigurationOutput, _a1 error) *S3API_GetBucketMetricsConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketMetricsConfiguration_Call) RunAndReturn(run func(*s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error)) *S3API_GetBucketMetricsConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketMetricsConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketMetricsConfigurationRequest(_a0 *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketMetricsConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketMetricsConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketMetricsConfigurationInput) *s3.GetBucketMetricsConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketMetricsConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketMetricsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketMetricsConfigurationRequest'
-type S3API_GetBucketMetricsConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketMetricsConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketMetricsConfigurationInput
-func (_e *S3API_Expecter) GetBucketMetricsConfigurationRequest(_a0 interface{}) *S3API_GetBucketMetricsConfigurationRequest_Call {
-	return &S3API_GetBucketMetricsConfigurationRequest_Call{Call: _e.mock.On("GetBucketMetricsConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketMetricsConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketMetricsConfigurationInput)) *S3API_GetBucketMetricsConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketMetricsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketMetricsConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketMetricsConfigurationOutput) *S3API_GetBucketMetricsConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketMetricsConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput)) *S3API_GetBucketMetricsConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketMetricsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketMetricsConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketMetricsConfigurationInput, _a2 ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketMetricsConfigurationWithContext")
-	}
-
-	var r0 *s3.GetBucketMetricsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) *s3.GetBucketMetricsConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketMetricsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketMetricsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketMetricsConfigurationWithContext'
-type S3API_GetBucketMetricsConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketMetricsConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketMetricsConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketMetricsConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketMetricsConfigurationWithContext_Call {
-	return &S3API_GetBucketMetricsConfigurationWithContext_Call{Call: _e.mock.On("GetBucketMetricsConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketMetricsConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketMetricsConfigurationInput, _a2 ...request.Option)) *S3API_GetBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketMetricsConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketMetricsConfigurationWithContext_Call) Return(_a0 *s3.GetBucketMetricsConfigurationOutput, _a1 error) *S3API_GetBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketMetricsConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error)) *S3API_GetBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketNotification provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketNotification(_a0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketNotification")
-	}
-
-	var r0 *s3.NotificationConfigurationDeprecated
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfigurationDeprecated); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.NotificationConfigurationDeprecated)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotification'
-type S3API_GetBucketNotification_Call struct {
-	*mock.Call
-}
-
-// GetBucketNotification is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketNotificationConfigurationRequest
-func (_e *S3API_Expecter) GetBucketNotification(_a0 interface{}) *S3API_GetBucketNotification_Call {
-	return &S3API_GetBucketNotification_Call{Call: _e.mock.On("GetBucketNotification", _a0)}
-}
-
-func (_c *S3API_GetBucketNotification_Call) Run(run func(_a0 *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotification_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketNotificationConfigurationRequest))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketNotification_Call) Return(_a0 *s3.NotificationConfigurationDeprecated, _a1 error) *S3API_GetBucketNotification_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketNotification_Call) RunAndReturn(run func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)) *S3API_GetBucketNotification_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketNotificationConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketNotificationConfiguration(_a0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketNotificationConfiguration")
-	}
-
-	var r0 *s3.NotificationConfiguration
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfiguration); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.NotificationConfiguration)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketNotificationConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfiguration'
-type S3API_GetBucketNotificationConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetBucketNotificationConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketNotificationConfigurationRequest
-func (_e *S3API_Expecter) GetBucketNotificationConfiguration(_a0 interface{}) *S3API_GetBucketNotificationConfiguration_Call {
-	return &S3API_GetBucketNotificationConfiguration_Call{Call: _e.mock.On("GetBucketNotificationConfiguration", _a0)}
-}
-
-func (_c *S3API_GetBucketNotificationConfiguration_Call) Run(run func(_a0 *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotificationConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketNotificationConfigurationRequest))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationConfiguration_Call) Return(_a0 *s3.NotificationConfiguration, _a1 error) *S3API_GetBucketNotificationConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationConfiguration_Call) RunAndReturn(run func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)) *S3API_GetBucketNotificationConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketNotificationConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketNotificationConfigurationRequest(_a0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketNotificationConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.NotificationConfiguration
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfiguration); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.NotificationConfiguration)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketNotificationConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfigurationRequest'
-type S3API_GetBucketNotificationConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketNotificationConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketNotificationConfigurationRequest
-func (_e *S3API_Expecter) GetBucketNotificationConfigurationRequest(_a0 interface{}) *S3API_GetBucketNotificationConfigurationRequest_Call {
-	return &S3API_GetBucketNotificationConfigurationRequest_Call{Call: _e.mock.On("GetBucketNotificationConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketNotificationConfigurationRequest_Call) Run(run func(_a0 *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotificationConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketNotificationConfigurationRequest))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.NotificationConfiguration) *S3API_GetBucketNotificationConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationConfigurationRequest_Call) RunAndReturn(run func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)) *S3API_GetBucketNotificationConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketNotificationConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketNotificationConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetBucketNotificationConfigurationRequest, _a2 ...request.Option) (*s3.NotificationConfiguration, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketNotificationConfigurationWithContext")
-	}
-
-	var r0 *s3.NotificationConfiguration
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfiguration, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) *s3.NotificationConfiguration); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.NotificationConfiguration)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketNotificationConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfigurationWithContext'
-type S3API_GetBucketNotificationConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketNotificationConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketNotificationConfigurationRequest
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketNotificationConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketNotificationConfigurationWithContext_Call {
-	return &S3API_GetBucketNotificationConfigurationWithContext_Call{Call: _e.mock.On("GetBucketNotificationConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketNotificationConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketNotificationConfigurationRequest, _a2 ...request.Option)) *S3API_GetBucketNotificationConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketNotificationConfigurationRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationConfigurationWithContext_Call) Return(_a0 *s3.NotificationConfiguration, _a1 error) *S3API_GetBucketNotificationConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfiguration, error)) *S3API_GetBucketNotificationConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketNotificationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketNotificationRequest(_a0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketNotificationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.NotificationConfigurationDeprecated
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfigurationDeprecated); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.NotificationConfigurationDeprecated)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketNotificationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationRequest'
-type S3API_GetBucketNotificationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketNotificationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketNotificationConfigurationRequest
-func (_e *S3API_Expecter) GetBucketNotificationRequest(_a0 interface{}) *S3API_GetBucketNotificationRequest_Call {
-	return &S3API_GetBucketNotificationRequest_Call{Call: _e.mock.On("GetBucketNotificationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketNotificationRequest_Call) Run(run func(_a0 *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotificationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketNotificationConfigurationRequest))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationRequest_Call) Return(_a0 *request.Request, _a1 *s3.NotificationConfigurationDeprecated) *S3API_GetBucketNotificationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationRequest_Call) RunAndReturn(run func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)) *S3API_GetBucketNotificationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketNotificationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketNotificationWithContext(_a0 aws.Context, _a1 *s3.GetBucketNotificationConfigurationRequest, _a2 ...request.Option) (*s3.NotificationConfigurationDeprecated, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketNotificationWithContext")
-	}
-
-	var r0 *s3.NotificationConfigurationDeprecated
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfigurationDeprecated, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) *s3.NotificationConfigurationDeprecated); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.NotificationConfigurationDeprecated)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketNotificationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationWithContext'
-type S3API_GetBucketNotificationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketNotificationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketNotificationConfigurationRequest
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketNotificationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketNotificationWithContext_Call {
-	return &S3API_GetBucketNotificationWithContext_Call{Call: _e.mock.On("GetBucketNotificationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketNotificationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketNotificationConfigurationRequest, _a2 ...request.Option)) *S3API_GetBucketNotificationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketNotificationConfigurationRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationWithContext_Call) Return(_a0 *s3.NotificationConfigurationDeprecated, _a1 error) *S3API_GetBucketNotificationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketNotificationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfigurationDeprecated, error)) *S3API_GetBucketNotificationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketOwnershipControls provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketOwnershipControls(_a0 *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketOwnershipControls")
-	}
-
-	var r0 *s3.GetBucketOwnershipControlsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) *s3.GetBucketOwnershipControlsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketOwnershipControlsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketOwnershipControlsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketOwnershipControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketOwnershipControls'
-type S3API_GetBucketOwnershipControls_Call struct {
-	*mock.Call
-}
-
-// GetBucketOwnershipControls is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketOwnershipControlsInput
-func (_e *S3API_Expecter) GetBucketOwnershipControls(_a0 interface{}) *S3API_GetBucketOwnershipControls_Call {
-	return &S3API_GetBucketOwnershipControls_Call{Call: _e.mock.On("GetBucketOwnershipControls", _a0)}
-}
-
-func (_c *S3API_GetBucketOwnershipControls_Call) Run(run func(_a0 *s3.GetBucketOwnershipControlsInput)) *S3API_GetBucketOwnershipControls_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketOwnershipControlsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketOwnershipControls_Call) Return(_a0 *s3.GetBucketOwnershipControlsOutput, _a1 error) *S3API_GetBucketOwnershipControls_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketOwnershipControls_Call) RunAndReturn(run func(*s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error)) *S3API_GetBucketOwnershipControls_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketOwnershipControlsRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketOwnershipControlsRequest(_a0 *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketOwnershipControlsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketOwnershipControlsOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketOwnershipControlsInput) *s3.GetBucketOwnershipControlsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketOwnershipControlsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketOwnershipControlsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketOwnershipControlsRequest'
-type S3API_GetBucketOwnershipControlsRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketOwnershipControlsRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketOwnershipControlsInput
-func (_e *S3API_Expecter) GetBucketOwnershipControlsRequest(_a0 interface{}) *S3API_GetBucketOwnershipControlsRequest_Call {
-	return &S3API_GetBucketOwnershipControlsRequest_Call{Call: _e.mock.On("GetBucketOwnershipControlsRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketOwnershipControlsRequest_Call) Run(run func(_a0 *s3.GetBucketOwnershipControlsInput)) *S3API_GetBucketOwnershipControlsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketOwnershipControlsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketOwnershipControlsRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketOwnershipControlsOutput) *S3API_GetBucketOwnershipControlsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketOwnershipControlsRequest_Call) RunAndReturn(run func(*s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput)) *S3API_GetBucketOwnershipControlsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketOwnershipControlsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketOwnershipControlsWithContext(_a0 aws.Context, _a1 *s3.GetBucketOwnershipControlsInput, _a2 ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketOwnershipControlsWithContext")
-	}
-
-	var r0 *s3.GetBucketOwnershipControlsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) *s3.GetBucketOwnershipControlsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketOwnershipControlsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketOwnershipControlsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketOwnershipControlsWithContext'
-type S3API_GetBucketOwnershipControlsWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketOwnershipControlsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketOwnershipControlsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketOwnershipControlsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketOwnershipControlsWithContext_Call {
-	return &S3API_GetBucketOwnershipControlsWithContext_Call{Call: _e.mock.On("GetBucketOwnershipControlsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketOwnershipControlsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketOwnershipControlsInput, _a2 ...request.Option)) *S3API_GetBucketOwnershipControlsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketOwnershipControlsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketOwnershipControlsWithContext_Call) Return(_a0 *s3.GetBucketOwnershipControlsOutput, _a1 error) *S3API_GetBucketOwnershipControlsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketOwnershipControlsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error)) *S3API_GetBucketOwnershipControlsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketPolicy provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketPolicy(_a0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketPolicy")
-	}
-
-	var r0 *s3.GetBucketPolicyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) *s3.GetBucketPolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketPolicyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicy'
-type S3API_GetBucketPolicy_Call struct {
-	*mock.Call
-}
-
-// GetBucketPolicy is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketPolicyInput
-func (_e *S3API_Expecter) GetBucketPolicy(_a0 interface{}) *S3API_GetBucketPolicy_Call {
-	return &S3API_GetBucketPolicy_Call{Call: _e.mock.On("GetBucketPolicy", _a0)}
-}
-
-func (_c *S3API_GetBucketPolicy_Call) Run(run func(_a0 *s3.GetBucketPolicyInput)) *S3API_GetBucketPolicy_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketPolicyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicy_Call) Return(_a0 *s3.GetBucketPolicyOutput, _a1 error) *S3API_GetBucketPolicy_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicy_Call) RunAndReturn(run func(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)) *S3API_GetBucketPolicy_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketPolicyRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketPolicyRequest(_a0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketPolicyRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketPolicyOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyInput) *s3.GetBucketPolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketPolicyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyRequest'
-type S3API_GetBucketPolicyRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketPolicyRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketPolicyInput
-func (_e *S3API_Expecter) GetBucketPolicyRequest(_a0 interface{}) *S3API_GetBucketPolicyRequest_Call {
-	return &S3API_GetBucketPolicyRequest_Call{Call: _e.mock.On("GetBucketPolicyRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketPolicyRequest_Call) Run(run func(_a0 *s3.GetBucketPolicyInput)) *S3API_GetBucketPolicyRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketPolicyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketPolicyOutput) *S3API_GetBucketPolicyRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyRequest_Call) RunAndReturn(run func(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)) *S3API_GetBucketPolicyRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketPolicyStatus provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketPolicyStatus(_a0 *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketPolicyStatus")
-	}
-
-	var r0 *s3.GetBucketPolicyStatusOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) *s3.GetBucketPolicyStatusOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketPolicyStatusOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyStatusInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketPolicyStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyStatus'
-type S3API_GetBucketPolicyStatus_Call struct {
-	*mock.Call
-}
-
-// GetBucketPolicyStatus is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketPolicyStatusInput
-func (_e *S3API_Expecter) GetBucketPolicyStatus(_a0 interface{}) *S3API_GetBucketPolicyStatus_Call {
-	return &S3API_GetBucketPolicyStatus_Call{Call: _e.mock.On("GetBucketPolicyStatus", _a0)}
-}
-
-func (_c *S3API_GetBucketPolicyStatus_Call) Run(run func(_a0 *s3.GetBucketPolicyStatusInput)) *S3API_GetBucketPolicyStatus_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketPolicyStatusInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyStatus_Call) Return(_a0 *s3.GetBucketPolicyStatusOutput, _a1 error) *S3API_GetBucketPolicyStatus_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyStatus_Call) RunAndReturn(run func(*s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error)) *S3API_GetBucketPolicyStatus_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketPolicyStatusRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketPolicyStatusRequest(_a0 *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketPolicyStatusRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketPolicyStatusOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyStatusInput) *s3.GetBucketPolicyStatusOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketPolicyStatusOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketPolicyStatusRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyStatusRequest'
-type S3API_GetBucketPolicyStatusRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketPolicyStatusRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketPolicyStatusInput
-func (_e *S3API_Expecter) GetBucketPolicyStatusRequest(_a0 interface{}) *S3API_GetBucketPolicyStatusRequest_Call {
-	return &S3API_GetBucketPolicyStatusRequest_Call{Call: _e.mock.On("GetBucketPolicyStatusRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketPolicyStatusRequest_Call) Run(run func(_a0 *s3.GetBucketPolicyStatusInput)) *S3API_GetBucketPolicyStatusRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketPolicyStatusInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyStatusRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketPolicyStatusOutput) *S3API_GetBucketPolicyStatusRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyStatusRequest_Call) RunAndReturn(run func(*s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput)) *S3API_GetBucketPolicyStatusRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketPolicyStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketPolicyStatusWithContext(_a0 aws.Context, _a1 *s3.GetBucketPolicyStatusInput, _a2 ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketPolicyStatusWithContext")
-	}
-
-	var r0 *s3.GetBucketPolicyStatusOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) (*s3.GetBucketPolicyStatusOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) *s3.GetBucketPolicyStatusOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketPolicyStatusOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketPolicyStatusWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyStatusWithContext'
-type S3API_GetBucketPolicyStatusWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketPolicyStatusWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketPolicyStatusInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketPolicyStatusWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketPolicyStatusWithContext_Call {
-	return &S3API_GetBucketPolicyStatusWithContext_Call{Call: _e.mock.On("GetBucketPolicyStatusWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketPolicyStatusWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketPolicyStatusInput, _a2 ...request.Option)) *S3API_GetBucketPolicyStatusWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketPolicyStatusInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyStatusWithContext_Call) Return(_a0 *s3.GetBucketPolicyStatusOutput, _a1 error) *S3API_GetBucketPolicyStatusWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyStatusWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) (*s3.GetBucketPolicyStatusOutput, error)) *S3API_GetBucketPolicyStatusWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketPolicyWithContext(_a0 aws.Context, _a1 *s3.GetBucketPolicyInput, _a2 ...request.Option) (*s3.GetBucketPolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketPolicyWithContext")
-	}
-
-	var r0 *s3.GetBucketPolicyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) (*s3.GetBucketPolicyOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) *s3.GetBucketPolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketPolicyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyWithContext'
-type S3API_GetBucketPolicyWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketPolicyWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketPolicyInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketPolicyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketPolicyWithContext_Call {
-	return &S3API_GetBucketPolicyWithContext_Call{Call: _e.mock.On("GetBucketPolicyWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketPolicyWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketPolicyInput, _a2 ...request.Option)) *S3API_GetBucketPolicyWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketPolicyInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyWithContext_Call) Return(_a0 *s3.GetBucketPolicyOutput, _a1 error) *S3API_GetBucketPolicyWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketPolicyWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) (*s3.GetBucketPolicyOutput, error)) *S3API_GetBucketPolicyWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketReplication provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketReplication(_a0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketReplication")
-	}
-
-	var r0 *s3.GetBucketReplicationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) *s3.GetBucketReplicationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketReplicationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketReplicationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketReplication'
-type S3API_GetBucketReplication_Call struct {
-	*mock.Call
-}
-
-// GetBucketReplication is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketReplicationInput
-func (_e *S3API_Expecter) GetBucketReplication(_a0 interface{}) *S3API_GetBucketReplication_Call {
-	return &S3API_GetBucketReplication_Call{Call: _e.mock.On("GetBucketReplication", _a0)}
-}
-
-func (_c *S3API_GetBucketReplication_Call) Run(run func(_a0 *s3.GetBucketReplicationInput)) *S3API_GetBucketReplication_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketReplicationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketReplication_Call) Return(_a0 *s3.GetBucketReplicationOutput, _a1 error) *S3API_GetBucketReplication_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketReplication_Call) RunAndReturn(run func(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)) *S3API_GetBucketReplication_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketReplicationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketReplicationRequest(_a0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketReplicationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketReplicationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketReplicationInput) *s3.GetBucketReplicationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketReplicationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketReplicationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketReplicationRequest'
-type S3API_GetBucketReplicationRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketReplicationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketReplicationInput
-func (_e *S3API_Expecter) GetBucketReplicationRequest(_a0 interface{}) *S3API_GetBucketReplicationRequest_Call {
-	return &S3API_GetBucketReplicationRequest_Call{Call: _e.mock.On("GetBucketReplicationRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketReplicationRequest_Call) Run(run func(_a0 *s3.GetBucketReplicationInput)) *S3API_GetBucketReplicationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketReplicationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketReplicationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketReplicationOutput) *S3API_GetBucketReplicationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketReplicationRequest_Call) RunAndReturn(run func(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)) *S3API_GetBucketReplicationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketReplicationWithContext(_a0 aws.Context, _a1 *s3.GetBucketReplicationInput, _a2 ...request.Option) (*s3.GetBucketReplicationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketReplicationWithContext")
-	}
-
-	var r0 *s3.GetBucketReplicationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) (*s3.GetBucketReplicationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) *s3.GetBucketReplicationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketReplicationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketReplicationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketReplicationWithContext'
-type S3API_GetBucketReplicationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketReplicationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketReplicationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketReplicationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketReplicationWithContext_Call {
-	return &S3API_GetBucketReplicationWithContext_Call{Call: _e.mock.On("GetBucketReplicationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketReplicationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketReplicationInput, _a2 ...request.Option)) *S3API_GetBucketReplicationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketReplicationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketReplicationWithContext_Call) Return(_a0 *s3.GetBucketReplicationOutput, _a1 error) *S3API_GetBucketReplicationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketReplicationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) (*s3.GetBucketReplicationOutput, error)) *S3API_GetBucketReplicationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketRequestPayment provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketRequestPayment(_a0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketRequestPayment")
-	}
-
-	var r0 *s3.GetBucketRequestPaymentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) *s3.GetBucketRequestPaymentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketRequestPaymentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketRequestPaymentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketRequestPayment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketRequestPayment'
-type S3API_GetBucketRequestPayment_Call struct {
-	*mock.Call
-}
-
-// GetBucketRequestPayment is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketRequestPaymentInput
-func (_e *S3API_Expecter) GetBucketRequestPayment(_a0 interface{}) *S3API_GetBucketRequestPayment_Call {
-	return &S3API_GetBucketRequestPayment_Call{Call: _e.mock.On("GetBucketRequestPayment", _a0)}
-}
-
-func (_c *S3API_GetBucketRequestPayment_Call) Run(run func(_a0 *s3.GetBucketRequestPaymentInput)) *S3API_GetBucketRequestPayment_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketRequestPaymentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketRequestPayment_Call) Return(_a0 *s3.GetBucketRequestPaymentOutput, _a1 error) *S3API_GetBucketRequestPayment_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketRequestPayment_Call) RunAndReturn(run func(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)) *S3API_GetBucketRequestPayment_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketRequestPaymentRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketRequestPaymentRequest(_a0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketRequestPaymentRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketRequestPaymentOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketRequestPaymentInput) *s3.GetBucketRequestPaymentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketRequestPaymentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketRequestPaymentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketRequestPaymentRequest'
-type S3API_GetBucketRequestPaymentRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketRequestPaymentRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketRequestPaymentInput
-func (_e *S3API_Expecter) GetBucketRequestPaymentRequest(_a0 interface{}) *S3API_GetBucketRequestPaymentRequest_Call {
-	return &S3API_GetBucketRequestPaymentRequest_Call{Call: _e.mock.On("GetBucketRequestPaymentRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketRequestPaymentRequest_Call) Run(run func(_a0 *s3.GetBucketRequestPaymentInput)) *S3API_GetBucketRequestPaymentRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketRequestPaymentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketRequestPaymentRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketRequestPaymentOutput) *S3API_GetBucketRequestPaymentRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketRequestPaymentRequest_Call) RunAndReturn(run func(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)) *S3API_GetBucketRequestPaymentRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketRequestPaymentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketRequestPaymentWithContext(_a0 aws.Context, _a1 *s3.GetBucketRequestPaymentInput, _a2 ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketRequestPaymentWithContext")
-	}
-
-	var r0 *s3.GetBucketRequestPaymentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) (*s3.GetBucketRequestPaymentOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) *s3.GetBucketRequestPaymentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketRequestPaymentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketRequestPaymentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketRequestPaymentWithContext'
-type S3API_GetBucketRequestPaymentWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketRequestPaymentWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketRequestPaymentInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketRequestPaymentWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketRequestPaymentWithContext_Call {
-	return &S3API_GetBucketRequestPaymentWithContext_Call{Call: _e.mock.On("GetBucketRequestPaymentWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketRequestPaymentWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketRequestPaymentInput, _a2 ...request.Option)) *S3API_GetBucketRequestPaymentWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketRequestPaymentInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketRequestPaymentWithContext_Call) Return(_a0 *s3.GetBucketRequestPaymentOutput, _a1 error) *S3API_GetBucketRequestPaymentWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketRequestPaymentWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) (*s3.GetBucketRequestPaymentOutput, error)) *S3API_GetBucketRequestPaymentWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketTagging provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketTagging(_a0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketTagging")
-	}
-
-	var r0 *s3.GetBucketTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) *s3.GetBucketTaggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketTaggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketTagging'
-type S3API_GetBucketTagging_Call struct {
-	*mock.Call
-}
-
-// GetBucketTagging is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketTaggingInput
-func (_e *S3API_Expecter) GetBucketTagging(_a0 interface{}) *S3API_GetBucketTagging_Call {
-	return &S3API_GetBucketTagging_Call{Call: _e.mock.On("GetBucketTagging", _a0)}
-}
-
-func (_c *S3API_GetBucketTagging_Call) Run(run func(_a0 *s3.GetBucketTaggingInput)) *S3API_GetBucketTagging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketTagging_Call) Return(_a0 *s3.GetBucketTaggingOutput, _a1 error) *S3API_GetBucketTagging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketTagging_Call) RunAndReturn(run func(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)) *S3API_GetBucketTagging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketTaggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketTaggingRequest(_a0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketTaggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketTaggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketTaggingInput) *s3.GetBucketTaggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketTaggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketTaggingRequest'
-type S3API_GetBucketTaggingRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketTaggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketTaggingInput
-func (_e *S3API_Expecter) GetBucketTaggingRequest(_a0 interface{}) *S3API_GetBucketTaggingRequest_Call {
-	return &S3API_GetBucketTaggingRequest_Call{Call: _e.mock.On("GetBucketTaggingRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketTaggingRequest_Call) Run(run func(_a0 *s3.GetBucketTaggingInput)) *S3API_GetBucketTaggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketTaggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketTaggingOutput) *S3API_GetBucketTaggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketTaggingRequest_Call) RunAndReturn(run func(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)) *S3API_GetBucketTaggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketTaggingWithContext(_a0 aws.Context, _a1 *s3.GetBucketTaggingInput, _a2 ...request.Option) (*s3.GetBucketTaggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketTaggingWithContext")
-	}
-
-	var r0 *s3.GetBucketTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) (*s3.GetBucketTaggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) *s3.GetBucketTaggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketTaggingWithContext'
-type S3API_GetBucketTaggingWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketTaggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketTaggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketTaggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketTaggingWithContext_Call {
-	return &S3API_GetBucketTaggingWithContext_Call{Call: _e.mock.On("GetBucketTaggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketTaggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketTaggingInput, _a2 ...request.Option)) *S3API_GetBucketTaggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketTaggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketTaggingWithContext_Call) Return(_a0 *s3.GetBucketTaggingOutput, _a1 error) *S3API_GetBucketTaggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketTaggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) (*s3.GetBucketTaggingOutput, error)) *S3API_GetBucketTaggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketVersioning provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketVersioning(_a0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketVersioning")
-	}
-
-	var r0 *s3.GetBucketVersioningOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) *s3.GetBucketVersioningOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketVersioningOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketVersioningInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketVersioning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketVersioning'
-type S3API_GetBucketVersioning_Call struct {
-	*mock.Call
-}
-
-// GetBucketVersioning is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketVersioningInput
-func (_e *S3API_Expecter) GetBucketVersioning(_a0 interface{}) *S3API_GetBucketVersioning_Call {
-	return &S3API_GetBucketVersioning_Call{Call: _e.mock.On("GetBucketVersioning", _a0)}
-}
-
-func (_c *S3API_GetBucketVersioning_Call) Run(run func(_a0 *s3.GetBucketVersioningInput)) *S3API_GetBucketVersioning_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketVersioningInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketVersioning_Call) Return(_a0 *s3.GetBucketVersioningOutput, _a1 error) *S3API_GetBucketVersioning_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketVersioning_Call) RunAndReturn(run func(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)) *S3API_GetBucketVersioning_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketVersioningRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketVersioningRequest(_a0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketVersioningRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketVersioningOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketVersioningInput) *s3.GetBucketVersioningOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketVersioningOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketVersioningRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketVersioningRequest'
-type S3API_GetBucketVersioningRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketVersioningRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketVersioningInput
-func (_e *S3API_Expecter) GetBucketVersioningRequest(_a0 interface{}) *S3API_GetBucketVersioningRequest_Call {
-	return &S3API_GetBucketVersioningRequest_Call{Call: _e.mock.On("GetBucketVersioningRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketVersioningRequest_Call) Run(run func(_a0 *s3.GetBucketVersioningInput)) *S3API_GetBucketVersioningRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketVersioningInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketVersioningRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketVersioningOutput) *S3API_GetBucketVersioningRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketVersioningRequest_Call) RunAndReturn(run func(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)) *S3API_GetBucketVersioningRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketVersioningWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketVersioningWithContext(_a0 aws.Context, _a1 *s3.GetBucketVersioningInput, _a2 ...request.Option) (*s3.GetBucketVersioningOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketVersioningWithContext")
-	}
-
-	var r0 *s3.GetBucketVersioningOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) (*s3.GetBucketVersioningOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) *s3.GetBucketVersioningOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketVersioningOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketVersioningWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketVersioningWithContext'
-type S3API_GetBucketVersioningWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketVersioningWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketVersioningInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketVersioningWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketVersioningWithContext_Call {
-	return &S3API_GetBucketVersioningWithContext_Call{Call: _e.mock.On("GetBucketVersioningWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketVersioningWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketVersioningInput, _a2 ...request.Option)) *S3API_GetBucketVersioningWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketVersioningInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketVersioningWithContext_Call) Return(_a0 *s3.GetBucketVersioningOutput, _a1 error) *S3API_GetBucketVersioningWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketVersioningWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) (*s3.GetBucketVersioningOutput, error)) *S3API_GetBucketVersioningWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketWebsite provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketWebsite(_a0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketWebsite")
-	}
-
-	var r0 *s3.GetBucketWebsiteOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) *s3.GetBucketWebsiteOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketWebsiteOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketWebsiteInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketWebsite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketWebsite'
-type S3API_GetBucketWebsite_Call struct {
-	*mock.Call
-}
-
-// GetBucketWebsite is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketWebsiteInput
-func (_e *S3API_Expecter) GetBucketWebsite(_a0 interface{}) *S3API_GetBucketWebsite_Call {
-	return &S3API_GetBucketWebsite_Call{Call: _e.mock.On("GetBucketWebsite", _a0)}
-}
-
-func (_c *S3API_GetBucketWebsite_Call) Run(run func(_a0 *s3.GetBucketWebsiteInput)) *S3API_GetBucketWebsite_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketWebsiteInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketWebsite_Call) Return(_a0 *s3.GetBucketWebsiteOutput, _a1 error) *S3API_GetBucketWebsite_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketWebsite_Call) RunAndReturn(run func(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)) *S3API_GetBucketWebsite_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketWebsiteRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetBucketWebsiteRequest(_a0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketWebsiteRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetBucketWebsiteOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetBucketWebsiteInput) *s3.GetBucketWebsiteOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetBucketWebsiteOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketWebsiteRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketWebsiteRequest'
-type S3API_GetBucketWebsiteRequest_Call struct {
-	*mock.Call
-}
-
-// GetBucketWebsiteRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetBucketWebsiteInput
-func (_e *S3API_Expecter) GetBucketWebsiteRequest(_a0 interface{}) *S3API_GetBucketWebsiteRequest_Call {
-	return &S3API_GetBucketWebsiteRequest_Call{Call: _e.mock.On("GetBucketWebsiteRequest", _a0)}
-}
-
-func (_c *S3API_GetBucketWebsiteRequest_Call) Run(run func(_a0 *s3.GetBucketWebsiteInput)) *S3API_GetBucketWebsiteRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetBucketWebsiteInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketWebsiteRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetBucketWebsiteOutput) *S3API_GetBucketWebsiteRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketWebsiteRequest_Call) RunAndReturn(run func(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)) *S3API_GetBucketWebsiteRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetBucketWebsiteWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetBucketWebsiteWithContext(_a0 aws.Context, _a1 *s3.GetBucketWebsiteInput, _a2 ...request.Option) (*s3.GetBucketWebsiteOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetBucketWebsiteWithContext")
-	}
-
-	var r0 *s3.GetBucketWebsiteOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) (*s3.GetBucketWebsiteOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) *s3.GetBucketWebsiteOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetBucketWebsiteOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetBucketWebsiteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketWebsiteWithContext'
-type S3API_GetBucketWebsiteWithContext_Call struct {
-	*mock.Call
-}
-
-// GetBucketWebsiteWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetBucketWebsiteInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetBucketWebsiteWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetBucketWebsiteWithContext_Call {
-	return &S3API_GetBucketWebsiteWithContext_Call{Call: _e.mock.On("GetBucketWebsiteWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetBucketWebsiteWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetBucketWebsiteInput, _a2 ...request.Option)) *S3API_GetBucketWebsiteWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetBucketWebsiteInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetBucketWebsiteWithContext_Call) Return(_a0 *s3.GetBucketWebsiteOutput, _a1 error) *S3API_GetBucketWebsiteWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetBucketWebsiteWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) (*s3.GetBucketWebsiteOutput, error)) *S3API_GetBucketWebsiteWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObject provides a mock function with given fields: _a0
-func (_m *S3API) GetObject(_a0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObject")
-	}
-
-	var r0 *s3.GetObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) (*s3.GetObjectOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) *s3.GetObjectOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObject'
-type S3API_GetObject_Call struct {
-	*mock.Call
-}
-
-// GetObject is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectInput
-func (_e *S3API_Expecter) GetObject(_a0 interface{}) *S3API_GetObject_Call {
-	return &S3API_GetObject_Call{Call: _e.mock.On("GetObject", _a0)}
-}
-
-func (_c *S3API_GetObject_Call) Run(run func(_a0 *s3.GetObjectInput)) *S3API_GetObject_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObject_Call) Return(_a0 *s3.GetObjectOutput, _a1 error) *S3API_GetObject_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObject_Call) RunAndReturn(run func(*s3.GetObjectInput) (*s3.GetObjectOutput, error)) *S3API_GetObject_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectAcl provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectAcl(_a0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectAcl")
-	}
-
-	var r0 *s3.GetObjectAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) *s3.GetObjectAclOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectAclInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAcl'
-type S3API_GetObjectAcl_Call struct {
-	*mock.Call
-}
-
-// GetObjectAcl is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectAclInput
-func (_e *S3API_Expecter) GetObjectAcl(_a0 interface{}) *S3API_GetObjectAcl_Call {
-	return &S3API_GetObjectAcl_Call{Call: _e.mock.On("GetObjectAcl", _a0)}
-}
-
-func (_c *S3API_GetObjectAcl_Call) Run(run func(_a0 *s3.GetObjectAclInput)) *S3API_GetObjectAcl_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectAcl_Call) Return(_a0 *s3.GetObjectAclOutput, _a1 error) *S3API_GetObjectAcl_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectAcl_Call) RunAndReturn(run func(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)) *S3API_GetObjectAcl_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectAclRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectAclRequest(_a0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectAclRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectAclOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectAclInput) *s3.GetObjectAclOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectAclOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAclRequest'
-type S3API_GetObjectAclRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectAclRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectAclInput
-func (_e *S3API_Expecter) GetObjectAclRequest(_a0 interface{}) *S3API_GetObjectAclRequest_Call {
-	return &S3API_GetObjectAclRequest_Call{Call: _e.mock.On("GetObjectAclRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectAclRequest_Call) Run(run func(_a0 *s3.GetObjectAclInput)) *S3API_GetObjectAclRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectAclRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectAclOutput) *S3API_GetObjectAclRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectAclRequest_Call) RunAndReturn(run func(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)) *S3API_GetObjectAclRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectAclWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectAclWithContext(_a0 aws.Context, _a1 *s3.GetObjectAclInput, _a2 ...request.Option) (*s3.GetObjectAclOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectAclWithContext")
-	}
-
-	var r0 *s3.GetObjectAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAclInput, ...request.Option) (*s3.GetObjectAclOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAclInput, ...request.Option) *s3.GetObjectAclOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectAclInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAclWithContext'
-type S3API_GetObjectAclWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectAclWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectAclInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectAclWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectAclWithContext_Call {
-	return &S3API_GetObjectAclWithContext_Call{Call: _e.mock.On("GetObjectAclWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectAclWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectAclInput, _a2 ...request.Option)) *S3API_GetObjectAclWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectAclInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectAclWithContext_Call) Return(_a0 *s3.GetObjectAclOutput, _a1 error) *S3API_GetObjectAclWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectAclWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectAclInput, ...request.Option) (*s3.GetObjectAclOutput, error)) *S3API_GetObjectAclWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectAttributes provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectAttributes(_a0 *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectAttributes")
-	}
-
-	var r0 *s3.GetObjectAttributesOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) *s3.GetObjectAttributesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectAttributesOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectAttributesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAttributes'
-type S3API_GetObjectAttributes_Call struct {
-	*mock.Call
-}
-
-// GetObjectAttributes is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectAttributesInput
-func (_e *S3API_Expecter) GetObjectAttributes(_a0 interface{}) *S3API_GetObjectAttributes_Call {
-	return &S3API_GetObjectAttributes_Call{Call: _e.mock.On("GetObjectAttributes", _a0)}
-}
-
-func (_c *S3API_GetObjectAttributes_Call) Run(run func(_a0 *s3.GetObjectAttributesInput)) *S3API_GetObjectAttributes_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectAttributesInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectAttributes_Call) Return(_a0 *s3.GetObjectAttributesOutput, _a1 error) *S3API_GetObjectAttributes_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectAttributes_Call) RunAndReturn(run func(*s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error)) *S3API_GetObjectAttributes_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectAttributesRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectAttributesRequest(_a0 *s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectAttributesRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectAttributesOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectAttributesInput) *s3.GetObjectAttributesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectAttributesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectAttributesRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAttributesRequest'
-type S3API_GetObjectAttributesRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectAttributesRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectAttributesInput
-func (_e *S3API_Expecter) GetObjectAttributesRequest(_a0 interface{}) *S3API_GetObjectAttributesRequest_Call {
-	return &S3API_GetObjectAttributesRequest_Call{Call: _e.mock.On("GetObjectAttributesRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectAttributesRequest_Call) Run(run func(_a0 *s3.GetObjectAttributesInput)) *S3API_GetObjectAttributesRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectAttributesInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectAttributesRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectAttributesOutput) *S3API_GetObjectAttributesRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectAttributesRequest_Call) RunAndReturn(run func(*s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput)) *S3API_GetObjectAttributesRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectAttributesWithContext(_a0 aws.Context, _a1 *s3.GetObjectAttributesInput, _a2 ...request.Option) (*s3.GetObjectAttributesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectAttributesWithContext")
-	}
-
-	var r0 *s3.GetObjectAttributesOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) (*s3.GetObjectAttributesOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) *s3.GetObjectAttributesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectAttributesOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectAttributesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAttributesWithContext'
-type S3API_GetObjectAttributesWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectAttributesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectAttributesInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectAttributesWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectAttributesWithContext_Call {
-	return &S3API_GetObjectAttributesWithContext_Call{Call: _e.mock.On("GetObjectAttributesWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectAttributesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectAttributesInput, _a2 ...request.Option)) *S3API_GetObjectAttributesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectAttributesInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectAttributesWithContext_Call) Return(_a0 *s3.GetObjectAttributesOutput, _a1 error) *S3API_GetObjectAttributesWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectAttributesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) (*s3.GetObjectAttributesOutput, error)) *S3API_GetObjectAttributesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectLegalHold provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectLegalHold(_a0 *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectLegalHold")
-	}
-
-	var r0 *s3.GetObjectLegalHoldOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) *s3.GetObjectLegalHoldOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectLegalHoldOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectLegalHoldInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectLegalHold_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLegalHold'
-type S3API_GetObjectLegalHold_Call struct {
-	*mock.Call
-}
-
-// GetObjectLegalHold is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectLegalHoldInput
-func (_e *S3API_Expecter) GetObjectLegalHold(_a0 interface{}) *S3API_GetObjectLegalHold_Call {
-	return &S3API_GetObjectLegalHold_Call{Call: _e.mock.On("GetObjectLegalHold", _a0)}
-}
-
-func (_c *S3API_GetObjectLegalHold_Call) Run(run func(_a0 *s3.GetObjectLegalHoldInput)) *S3API_GetObjectLegalHold_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectLegalHoldInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectLegalHold_Call) Return(_a0 *s3.GetObjectLegalHoldOutput, _a1 error) *S3API_GetObjectLegalHold_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectLegalHold_Call) RunAndReturn(run func(*s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error)) *S3API_GetObjectLegalHold_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectLegalHoldRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectLegalHoldRequest(_a0 *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectLegalHoldRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectLegalHoldOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectLegalHoldInput) *s3.GetObjectLegalHoldOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectLegalHoldOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectLegalHoldRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLegalHoldRequest'
-type S3API_GetObjectLegalHoldRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectLegalHoldRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectLegalHoldInput
-func (_e *S3API_Expecter) GetObjectLegalHoldRequest(_a0 interface{}) *S3API_GetObjectLegalHoldRequest_Call {
-	return &S3API_GetObjectLegalHoldRequest_Call{Call: _e.mock.On("GetObjectLegalHoldRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectLegalHoldRequest_Call) Run(run func(_a0 *s3.GetObjectLegalHoldInput)) *S3API_GetObjectLegalHoldRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectLegalHoldInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectLegalHoldRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectLegalHoldOutput) *S3API_GetObjectLegalHoldRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectLegalHoldRequest_Call) RunAndReturn(run func(*s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput)) *S3API_GetObjectLegalHoldRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectLegalHoldWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectLegalHoldWithContext(_a0 aws.Context, _a1 *s3.GetObjectLegalHoldInput, _a2 ...request.Option) (*s3.GetObjectLegalHoldOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectLegalHoldWithContext")
-	}
-
-	var r0 *s3.GetObjectLegalHoldOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) (*s3.GetObjectLegalHoldOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) *s3.GetObjectLegalHoldOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectLegalHoldOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectLegalHoldWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLegalHoldWithContext'
-type S3API_GetObjectLegalHoldWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectLegalHoldWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectLegalHoldInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectLegalHoldWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectLegalHoldWithContext_Call {
-	return &S3API_GetObjectLegalHoldWithContext_Call{Call: _e.mock.On("GetObjectLegalHoldWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectLegalHoldWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectLegalHoldInput, _a2 ...request.Option)) *S3API_GetObjectLegalHoldWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectLegalHoldInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectLegalHoldWithContext_Call) Return(_a0 *s3.GetObjectLegalHoldOutput, _a1 error) *S3API_GetObjectLegalHoldWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectLegalHoldWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) (*s3.GetObjectLegalHoldOutput, error)) *S3API_GetObjectLegalHoldWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectLockConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectLockConfiguration(_a0 *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectLockConfiguration")
-	}
-
-	var r0 *s3.GetObjectLockConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) *s3.GetObjectLockConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectLockConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectLockConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectLockConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLockConfiguration'
-type S3API_GetObjectLockConfiguration_Call struct {
-	*mock.Call
-}
-
-// GetObjectLockConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectLockConfigurationInput
-func (_e *S3API_Expecter) GetObjectLockConfiguration(_a0 interface{}) *S3API_GetObjectLockConfiguration_Call {
-	return &S3API_GetObjectLockConfiguration_Call{Call: _e.mock.On("GetObjectLockConfiguration", _a0)}
-}
-
-func (_c *S3API_GetObjectLockConfiguration_Call) Run(run func(_a0 *s3.GetObjectLockConfigurationInput)) *S3API_GetObjectLockConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectLockConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectLockConfiguration_Call) Return(_a0 *s3.GetObjectLockConfigurationOutput, _a1 error) *S3API_GetObjectLockConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectLockConfiguration_Call) RunAndReturn(run func(*s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error)) *S3API_GetObjectLockConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectLockConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectLockConfigurationRequest(_a0 *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectLockConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectLockConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectLockConfigurationInput) *s3.GetObjectLockConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectLockConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectLockConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLockConfigurationRequest'
-type S3API_GetObjectLockConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectLockConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectLockConfigurationInput
-func (_e *S3API_Expecter) GetObjectLockConfigurationRequest(_a0 interface{}) *S3API_GetObjectLockConfigurationRequest_Call {
-	return &S3API_GetObjectLockConfigurationRequest_Call{Call: _e.mock.On("GetObjectLockConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectLockConfigurationRequest_Call) Run(run func(_a0 *s3.GetObjectLockConfigurationInput)) *S3API_GetObjectLockConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectLockConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectLockConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectLockConfigurationOutput) *S3API_GetObjectLockConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectLockConfigurationRequest_Call) RunAndReturn(run func(*s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput)) *S3API_GetObjectLockConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectLockConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectLockConfigurationWithContext(_a0 aws.Context, _a1 *s3.GetObjectLockConfigurationInput, _a2 ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectLockConfigurationWithContext")
-	}
-
-	var r0 *s3.GetObjectLockConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) (*s3.GetObjectLockConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) *s3.GetObjectLockConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectLockConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectLockConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLockConfigurationWithContext'
-type S3API_GetObjectLockConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectLockConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectLockConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectLockConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectLockConfigurationWithContext_Call {
-	return &S3API_GetObjectLockConfigurationWithContext_Call{Call: _e.mock.On("GetObjectLockConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectLockConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectLockConfigurationInput, _a2 ...request.Option)) *S3API_GetObjectLockConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectLockConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectLockConfigurationWithContext_Call) Return(_a0 *s3.GetObjectLockConfigurationOutput, _a1 error) *S3API_GetObjectLockConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectLockConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) (*s3.GetObjectLockConfigurationOutput, error)) *S3API_GetObjectLockConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectRequest(_a0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectInput) *s3.GetObjectOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRequest'
-type S3API_GetObjectRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectInput
-func (_e *S3API_Expecter) GetObjectRequest(_a0 interface{}) *S3API_GetObjectRequest_Call {
-	return &S3API_GetObjectRequest_Call{Call: _e.mock.On("GetObjectRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectRequest_Call) Run(run func(_a0 *s3.GetObjectInput)) *S3API_GetObjectRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectOutput) *S3API_GetObjectRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectRequest_Call) RunAndReturn(run func(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)) *S3API_GetObjectRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectRetention provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectRetention(_a0 *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectRetention")
-	}
-
-	var r0 *s3.GetObjectRetentionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) *s3.GetObjectRetentionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectRetentionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectRetentionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectRetention_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRetention'
-type S3API_GetObjectRetention_Call struct {
-	*mock.Call
-}
-
-// GetObjectRetention is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectRetentionInput
-func (_e *S3API_Expecter) GetObjectRetention(_a0 interface{}) *S3API_GetObjectRetention_Call {
-	return &S3API_GetObjectRetention_Call{Call: _e.mock.On("GetObjectRetention", _a0)}
-}
-
-func (_c *S3API_GetObjectRetention_Call) Run(run func(_a0 *s3.GetObjectRetentionInput)) *S3API_GetObjectRetention_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectRetentionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectRetention_Call) Return(_a0 *s3.GetObjectRetentionOutput, _a1 error) *S3API_GetObjectRetention_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectRetention_Call) RunAndReturn(run func(*s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error)) *S3API_GetObjectRetention_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectRetentionRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectRetentionRequest(_a0 *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectRetentionRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectRetentionOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectRetentionInput) *s3.GetObjectRetentionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectRetentionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectRetentionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRetentionRequest'
-type S3API_GetObjectRetentionRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectRetentionRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectRetentionInput
-func (_e *S3API_Expecter) GetObjectRetentionRequest(_a0 interface{}) *S3API_GetObjectRetentionRequest_Call {
-	return &S3API_GetObjectRetentionRequest_Call{Call: _e.mock.On("GetObjectRetentionRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectRetentionRequest_Call) Run(run func(_a0 *s3.GetObjectRetentionInput)) *S3API_GetObjectRetentionRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectRetentionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectRetentionRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectRetentionOutput) *S3API_GetObjectRetentionRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectRetentionRequest_Call) RunAndReturn(run func(*s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput)) *S3API_GetObjectRetentionRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectRetentionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectRetentionWithContext(_a0 aws.Context, _a1 *s3.GetObjectRetentionInput, _a2 ...request.Option) (*s3.GetObjectRetentionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectRetentionWithContext")
-	}
-
-	var r0 *s3.GetObjectRetentionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) (*s3.GetObjectRetentionOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) *s3.GetObjectRetentionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectRetentionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectRetentionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRetentionWithContext'
-type S3API_GetObjectRetentionWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectRetentionWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectRetentionInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectRetentionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectRetentionWithContext_Call {
-	return &S3API_GetObjectRetentionWithContext_Call{Call: _e.mock.On("GetObjectRetentionWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectRetentionWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectRetentionInput, _a2 ...request.Option)) *S3API_GetObjectRetentionWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectRetentionInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectRetentionWithContext_Call) Return(_a0 *s3.GetObjectRetentionOutput, _a1 error) *S3API_GetObjectRetentionWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectRetentionWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) (*s3.GetObjectRetentionOutput, error)) *S3API_GetObjectRetentionWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectTagging provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectTagging(_a0 *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectTagging")
-	}
-
-	var r0 *s3.GetObjectTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) *s3.GetObjectTaggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectTaggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTagging'
-type S3API_GetObjectTagging_Call struct {
-	*mock.Call
-}
-
-// GetObjectTagging is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectTaggingInput
-func (_e *S3API_Expecter) GetObjectTagging(_a0 interface{}) *S3API_GetObjectTagging_Call {
-	return &S3API_GetObjectTagging_Call{Call: _e.mock.On("GetObjectTagging", _a0)}
-}
-
-func (_c *S3API_GetObjectTagging_Call) Run(run func(_a0 *s3.GetObjectTaggingInput)) *S3API_GetObjectTagging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectTagging_Call) Return(_a0 *s3.GetObjectTaggingOutput, _a1 error) *S3API_GetObjectTagging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectTagging_Call) RunAndReturn(run func(*s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error)) *S3API_GetObjectTagging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectTaggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectTaggingRequest(_a0 *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectTaggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectTaggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectTaggingInput) *s3.GetObjectTaggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectTaggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTaggingRequest'
-type S3API_GetObjectTaggingRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectTaggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectTaggingInput
-func (_e *S3API_Expecter) GetObjectTaggingRequest(_a0 interface{}) *S3API_GetObjectTaggingRequest_Call {
-	return &S3API_GetObjectTaggingRequest_Call{Call: _e.mock.On("GetObjectTaggingRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectTaggingRequest_Call) Run(run func(_a0 *s3.GetObjectTaggingInput)) *S3API_GetObjectTaggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectTaggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectTaggingOutput) *S3API_GetObjectTaggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectTaggingRequest_Call) RunAndReturn(run func(*s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput)) *S3API_GetObjectTaggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectTaggingWithContext(_a0 aws.Context, _a1 *s3.GetObjectTaggingInput, _a2 ...request.Option) (*s3.GetObjectTaggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectTaggingWithContext")
-	}
-
-	var r0 *s3.GetObjectTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) (*s3.GetObjectTaggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) *s3.GetObjectTaggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTaggingWithContext'
-type S3API_GetObjectTaggingWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectTaggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectTaggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectTaggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectTaggingWithContext_Call {
-	return &S3API_GetObjectTaggingWithContext_Call{Call: _e.mock.On("GetObjectTaggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectTaggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectTaggingInput, _a2 ...request.Option)) *S3API_GetObjectTaggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectTaggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectTaggingWithContext_Call) Return(_a0 *s3.GetObjectTaggingOutput, _a1 error) *S3API_GetObjectTaggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectTaggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) (*s3.GetObjectTaggingOutput, error)) *S3API_GetObjectTaggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectTorrent provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectTorrent(_a0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectTorrent")
-	}
-
-	var r0 *s3.GetObjectTorrentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) *s3.GetObjectTorrentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectTorrentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectTorrentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectTorrent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTorrent'
-type S3API_GetObjectTorrent_Call struct {
-	*mock.Call
-}
-
-// GetObjectTorrent is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectTorrentInput
-func (_e *S3API_Expecter) GetObjectTorrent(_a0 interface{}) *S3API_GetObjectTorrent_Call {
-	return &S3API_GetObjectTorrent_Call{Call: _e.mock.On("GetObjectTorrent", _a0)}
-}
-
-func (_c *S3API_GetObjectTorrent_Call) Run(run func(_a0 *s3.GetObjectTorrentInput)) *S3API_GetObjectTorrent_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectTorrentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectTorrent_Call) Return(_a0 *s3.GetObjectTorrentOutput, _a1 error) *S3API_GetObjectTorrent_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectTorrent_Call) RunAndReturn(run func(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)) *S3API_GetObjectTorrent_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectTorrentRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetObjectTorrentRequest(_a0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectTorrentRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetObjectTorrentOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetObjectTorrentInput) *s3.GetObjectTorrentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetObjectTorrentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectTorrentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTorrentRequest'
-type S3API_GetObjectTorrentRequest_Call struct {
-	*mock.Call
-}
-
-// GetObjectTorrentRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetObjectTorrentInput
-func (_e *S3API_Expecter) GetObjectTorrentRequest(_a0 interface{}) *S3API_GetObjectTorrentRequest_Call {
-	return &S3API_GetObjectTorrentRequest_Call{Call: _e.mock.On("GetObjectTorrentRequest", _a0)}
-}
-
-func (_c *S3API_GetObjectTorrentRequest_Call) Run(run func(_a0 *s3.GetObjectTorrentInput)) *S3API_GetObjectTorrentRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetObjectTorrentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectTorrentRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetObjectTorrentOutput) *S3API_GetObjectTorrentRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectTorrentRequest_Call) RunAndReturn(run func(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)) *S3API_GetObjectTorrentRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectTorrentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectTorrentWithContext(_a0 aws.Context, _a1 *s3.GetObjectTorrentInput, _a2 ...request.Option) (*s3.GetObjectTorrentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectTorrentWithContext")
-	}
-
-	var r0 *s3.GetObjectTorrentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) (*s3.GetObjectTorrentOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) *s3.GetObjectTorrentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectTorrentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectTorrentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTorrentWithContext'
-type S3API_GetObjectTorrentWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectTorrentWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectTorrentInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectTorrentWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectTorrentWithContext_Call {
-	return &S3API_GetObjectTorrentWithContext_Call{Call: _e.mock.On("GetObjectTorrentWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectTorrentWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectTorrentInput, _a2 ...request.Option)) *S3API_GetObjectTorrentWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectTorrentInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectTorrentWithContext_Call) Return(_a0 *s3.GetObjectTorrentOutput, _a1 error) *S3API_GetObjectTorrentWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectTorrentWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) (*s3.GetObjectTorrentOutput, error)) *S3API_GetObjectTorrentWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetObjectWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetObjectWithContext(_a0 aws.Context, _a1 *s3.GetObjectInput, _a2 ...request.Option) (*s3.GetObjectOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetObjectWithContext")
-	}
-
-	var r0 *s3.GetObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectInput, ...request.Option) (*s3.GetObjectOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectInput, ...request.Option) *s3.GetObjectOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectWithContext'
-type S3API_GetObjectWithContext_Call struct {
-	*mock.Call
-}
-
-// GetObjectWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetObjectInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetObjectWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetObjectWithContext_Call {
-	return &S3API_GetObjectWithContext_Call{Call: _e.mock.On("GetObjectWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetObjectWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetObjectInput, _a2 ...request.Option)) *S3API_GetObjectWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetObjectWithContext_Call) Return(_a0 *s3.GetObjectOutput, _a1 error) *S3API_GetObjectWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetObjectWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetObjectInput, ...request.Option) (*s3.GetObjectOutput, error)) *S3API_GetObjectWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetPublicAccessBlock provides a mock function with given fields: _a0
-func (_m *S3API) GetPublicAccessBlock(_a0 *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetPublicAccessBlock")
-	}
-
-	var r0 *s3.GetPublicAccessBlockOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) *s3.GetPublicAccessBlockOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetPublicAccessBlockOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetPublicAccessBlockInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetPublicAccessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicAccessBlock'
-type S3API_GetPublicAccessBlock_Call struct {
-	*mock.Call
-}
-
-// GetPublicAccessBlock is a helper method to define mock.On call
-//   - _a0 *s3.GetPublicAccessBlockInput
-func (_e *S3API_Expecter) GetPublicAccessBlock(_a0 interface{}) *S3API_GetPublicAccessBlock_Call {
-	return &S3API_GetPublicAccessBlock_Call{Call: _e.mock.On("GetPublicAccessBlock", _a0)}
-}
-
-func (_c *S3API_GetPublicAccessBlock_Call) Run(run func(_a0 *s3.GetPublicAccessBlockInput)) *S3API_GetPublicAccessBlock_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetPublicAccessBlockInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetPublicAccessBlock_Call) Return(_a0 *s3.GetPublicAccessBlockOutput, _a1 error) *S3API_GetPublicAccessBlock_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetPublicAccessBlock_Call) RunAndReturn(run func(*s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error)) *S3API_GetPublicAccessBlock_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetPublicAccessBlockRequest provides a mock function with given fields: _a0
-func (_m *S3API) GetPublicAccessBlockRequest(_a0 *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetPublicAccessBlockRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.GetPublicAccessBlockOutput
-	if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.GetPublicAccessBlockInput) *s3.GetPublicAccessBlockOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.GetPublicAccessBlockOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_GetPublicAccessBlockRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicAccessBlockRequest'
-type S3API_GetPublicAccessBlockRequest_Call struct {
-	*mock.Call
-}
-
-// GetPublicAccessBlockRequest is a helper method to define mock.On call
-//   - _a0 *s3.GetPublicAccessBlockInput
-func (_e *S3API_Expecter) GetPublicAccessBlockRequest(_a0 interface{}) *S3API_GetPublicAccessBlockRequest_Call {
-	return &S3API_GetPublicAccessBlockRequest_Call{Call: _e.mock.On("GetPublicAccessBlockRequest", _a0)}
-}
-
-func (_c *S3API_GetPublicAccessBlockRequest_Call) Run(run func(_a0 *s3.GetPublicAccessBlockInput)) *S3API_GetPublicAccessBlockRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.GetPublicAccessBlockInput))
-	})
-	return _c
-}
-
-func (_c *S3API_GetPublicAccessBlockRequest_Call) Return(_a0 *request.Request, _a1 *s3.GetPublicAccessBlockOutput) *S3API_GetPublicAccessBlockRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetPublicAccessBlockRequest_Call) RunAndReturn(run func(*s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput)) *S3API_GetPublicAccessBlockRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetPublicAccessBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) GetPublicAccessBlockWithContext(_a0 aws.Context, _a1 *s3.GetPublicAccessBlockInput, _a2 ...request.Option) (*s3.GetPublicAccessBlockOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetPublicAccessBlockWithContext")
-	}
-
-	var r0 *s3.GetPublicAccessBlockOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) (*s3.GetPublicAccessBlockOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) *s3.GetPublicAccessBlockOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.GetPublicAccessBlockOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_GetPublicAccessBlockWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicAccessBlockWithContext'
-type S3API_GetPublicAccessBlockWithContext_Call struct {
-	*mock.Call
-}
-
-// GetPublicAccessBlockWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.GetPublicAccessBlockInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) GetPublicAccessBlockWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_GetPublicAccessBlockWithContext_Call {
-	return &S3API_GetPublicAccessBlockWithContext_Call{Call: _e.mock.On("GetPublicAccessBlockWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_GetPublicAccessBlockWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.GetPublicAccessBlockInput, _a2 ...request.Option)) *S3API_GetPublicAccessBlockWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.GetPublicAccessBlockInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_GetPublicAccessBlockWithContext_Call) Return(_a0 *s3.GetPublicAccessBlockOutput, _a1 error) *S3API_GetPublicAccessBlockWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_GetPublicAccessBlockWithContext_Call) RunAndReturn(run func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) (*s3.GetPublicAccessBlockOutput, error)) *S3API_GetPublicAccessBlockWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// HeadBucket provides a mock function with given fields: _a0
-func (_m *S3API) HeadBucket(_a0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for HeadBucket")
-	}
-
-	var r0 *s3.HeadBucketOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) *s3.HeadBucketOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.HeadBucketOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.HeadBucketInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_HeadBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucket'
-type S3API_HeadBucket_Call struct {
-	*mock.Call
-}
-
-// HeadBucket is a helper method to define mock.On call
-//   - _a0 *s3.HeadBucketInput
-func (_e *S3API_Expecter) HeadBucket(_a0 interface{}) *S3API_HeadBucket_Call {
-	return &S3API_HeadBucket_Call{Call: _e.mock.On("HeadBucket", _a0)}
-}
-
-func (_c *S3API_HeadBucket_Call) Run(run func(_a0 *s3.HeadBucketInput)) *S3API_HeadBucket_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_HeadBucket_Call) Return(_a0 *s3.HeadBucketOutput, _a1 error) *S3API_HeadBucket_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_HeadBucket_Call) RunAndReturn(run func(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error)) *S3API_HeadBucket_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// HeadBucketRequest provides a mock function with given fields: _a0
-func (_m *S3API) HeadBucketRequest(_a0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for HeadBucketRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.HeadBucketOutput
-	if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.HeadBucketInput) *s3.HeadBucketOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.HeadBucketOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_HeadBucketRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucketRequest'
-type S3API_HeadBucketRequest_Call struct {
-	*mock.Call
-}
-
-// HeadBucketRequest is a helper method to define mock.On call
-//   - _a0 *s3.HeadBucketInput
-func (_e *S3API_Expecter) HeadBucketRequest(_a0 interface{}) *S3API_HeadBucketRequest_Call {
-	return &S3API_HeadBucketRequest_Call{Call: _e.mock.On("HeadBucketRequest", _a0)}
-}
-
-func (_c *S3API_HeadBucketRequest_Call) Run(run func(_a0 *s3.HeadBucketInput)) *S3API_HeadBucketRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_HeadBucketRequest_Call) Return(_a0 *request.Request, _a1 *s3.HeadBucketOutput) *S3API_HeadBucketRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_HeadBucketRequest_Call) RunAndReturn(run func(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)) *S3API_HeadBucketRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// HeadBucketWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) HeadBucketWithContext(_a0 aws.Context, _a1 *s3.HeadBucketInput, _a2 ...request.Option) (*s3.HeadBucketOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for HeadBucketWithContext")
-	}
-
-	var r0 *s3.HeadBucketOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.Option) (*s3.HeadBucketOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.Option) *s3.HeadBucketOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.HeadBucketOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.HeadBucketInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_HeadBucketWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucketWithContext'
-type S3API_HeadBucketWithContext_Call struct {
-	*mock.Call
-}
-
-// HeadBucketWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.HeadBucketInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) HeadBucketWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_HeadBucketWithContext_Call {
-	return &S3API_HeadBucketWithContext_Call{Call: _e.mock.On("HeadBucketWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_HeadBucketWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.HeadBucketInput, _a2 ...request.Option)) *S3API_HeadBucketWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.HeadBucketInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_HeadBucketWithContext_Call) Return(_a0 *s3.HeadBucketOutput, _a1 error) *S3API_HeadBucketWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_HeadBucketWithContext_Call) RunAndReturn(run func(aws.Context, *s3.HeadBucketInput, ...request.Option) (*s3.HeadBucketOutput, error)) *S3API_HeadBucketWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// HeadObject provides a mock function with given fields: _a0
-func (_m *S3API) HeadObject(_a0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for HeadObject")
-	}
-
-	var r0 *s3.HeadObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) *s3.HeadObjectOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.HeadObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.HeadObjectInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_HeadObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObject'
-type S3API_HeadObject_Call struct {
-	*mock.Call
-}
-
-// HeadObject is a helper method to define mock.On call
-//   - _a0 *s3.HeadObjectInput
-func (_e *S3API_Expecter) HeadObject(_a0 interface{}) *S3API_HeadObject_Call {
-	return &S3API_HeadObject_Call{Call: _e.mock.On("HeadObject", _a0)}
-}
-
-func (_c *S3API_HeadObject_Call) Run(run func(_a0 *s3.HeadObjectInput)) *S3API_HeadObject_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_HeadObject_Call) Return(_a0 *s3.HeadObjectOutput, _a1 error) *S3API_HeadObject_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_HeadObject_Call) RunAndReturn(run func(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error)) *S3API_HeadObject_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// HeadObjectRequest provides a mock function with given fields: _a0
-func (_m *S3API) HeadObjectRequest(_a0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for HeadObjectRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.HeadObjectOutput
-	if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.HeadObjectInput) *s3.HeadObjectOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.HeadObjectOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_HeadObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObjectRequest'
-type S3API_HeadObjectRequest_Call struct {
-	*mock.Call
-}
-
-// HeadObjectRequest is a helper method to define mock.On call
-//   - _a0 *s3.HeadObjectInput
-func (_e *S3API_Expecter) HeadObjectRequest(_a0 interface{}) *S3API_HeadObjectRequest_Call {
-	return &S3API_HeadObjectRequest_Call{Call: _e.mock.On("HeadObjectRequest", _a0)}
-}
-
-func (_c *S3API_HeadObjectRequest_Call) Run(run func(_a0 *s3.HeadObjectInput)) *S3API_HeadObjectRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_HeadObjectRequest_Call) Return(_a0 *request.Request, _a1 *s3.HeadObjectOutput) *S3API_HeadObjectRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_HeadObjectRequest_Call) RunAndReturn(run func(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)) *S3API_HeadObjectRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// HeadObjectWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) HeadObjectWithContext(_a0 aws.Context, _a1 *s3.HeadObjectInput, _a2 ...request.Option) (*s3.HeadObjectOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for HeadObjectWithContext")
-	}
-
-	var r0 *s3.HeadObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.Option) (*s3.HeadObjectOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.Option) *s3.HeadObjectOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.HeadObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.HeadObjectInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_HeadObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObjectWithContext'
-type S3API_HeadObjectWithContext_Call struct {
-	*mock.Call
-}
-
-// HeadObjectWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.HeadObjectInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) HeadObjectWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_HeadObjectWithContext_Call {
-	return &S3API_HeadObjectWithContext_Call{Call: _e.mock.On("HeadObjectWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_HeadObjectWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.HeadObjectInput, _a2 ...request.Option)) *S3API_HeadObjectWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.HeadObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_HeadObjectWithContext_Call) Return(_a0 *s3.HeadObjectOutput, _a1 error) *S3API_HeadObjectWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_HeadObjectWithContext_Call) RunAndReturn(run func(aws.Context, *s3.HeadObjectInput, ...request.Option) (*s3.HeadObjectOutput, error)) *S3API_HeadObjectWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketAnalyticsConfigurations provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketAnalyticsConfigurations(_a0 *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketAnalyticsConfigurations")
-	}
-
-	var r0 *s3.ListBucketAnalyticsConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) *s3.ListBucketAnalyticsConfigurationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketAnalyticsConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketAnalyticsConfigurationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketAnalyticsConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketAnalyticsConfigurations'
-type S3API_ListBucketAnalyticsConfigurations_Call struct {
-	*mock.Call
-}
-
-// ListBucketAnalyticsConfigurations is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketAnalyticsConfigurationsInput
-func (_e *S3API_Expecter) ListBucketAnalyticsConfigurations(_a0 interface{}) *S3API_ListBucketAnalyticsConfigurations_Call {
-	return &S3API_ListBucketAnalyticsConfigurations_Call{Call: _e.mock.On("ListBucketAnalyticsConfigurations", _a0)}
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurations_Call) Run(run func(_a0 *s3.ListBucketAnalyticsConfigurationsInput)) *S3API_ListBucketAnalyticsConfigurations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketAnalyticsConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurations_Call) Return(_a0 *s3.ListBucketAnalyticsConfigurationsOutput, _a1 error) *S3API_ListBucketAnalyticsConfigurations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurations_Call) RunAndReturn(run func(*s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error)) *S3API_ListBucketAnalyticsConfigurations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketAnalyticsConfigurationsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketAnalyticsConfigurationsRequest(_a0 *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketAnalyticsConfigurationsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListBucketAnalyticsConfigurationsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketAnalyticsConfigurationsInput) *s3.ListBucketAnalyticsConfigurationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListBucketAnalyticsConfigurationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketAnalyticsConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketAnalyticsConfigurationsRequest'
-type S3API_ListBucketAnalyticsConfigurationsRequest_Call struct {
-	*mock.Call
-}
-
-// ListBucketAnalyticsConfigurationsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketAnalyticsConfigurationsInput
-func (_e *S3API_Expecter) ListBucketAnalyticsConfigurationsRequest(_a0 interface{}) *S3API_ListBucketAnalyticsConfigurationsRequest_Call {
-	return &S3API_ListBucketAnalyticsConfigurationsRequest_Call{Call: _e.mock.On("ListBucketAnalyticsConfigurationsRequest", _a0)}
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurationsRequest_Call) Run(run func(_a0 *s3.ListBucketAnalyticsConfigurationsInput)) *S3API_ListBucketAnalyticsConfigurationsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketAnalyticsConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurationsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListBucketAnalyticsConfigurationsOutput) *S3API_ListBucketAnalyticsConfigurationsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurationsRequest_Call) RunAndReturn(run func(*s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput)) *S3API_ListBucketAnalyticsConfigurationsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketAnalyticsConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListBucketAnalyticsConfigurationsWithContext(_a0 aws.Context, _a1 *s3.ListBucketAnalyticsConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketAnalyticsConfigurationsWithContext")
-	}
-
-	var r0 *s3.ListBucketAnalyticsConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) *s3.ListBucketAnalyticsConfigurationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketAnalyticsConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketAnalyticsConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketAnalyticsConfigurationsWithContext'
-type S3API_ListBucketAnalyticsConfigurationsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListBucketAnalyticsConfigurationsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListBucketAnalyticsConfigurationsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListBucketAnalyticsConfigurationsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call {
-	return &S3API_ListBucketAnalyticsConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketAnalyticsConfigurationsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurationsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListBucketAnalyticsConfigurationsInput, _a2 ...request.Option)) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListBucketAnalyticsConfigurationsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurationsWithContext_Call) Return(_a0 *s3.ListBucketAnalyticsConfigurationsOutput, _a1 error) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketAnalyticsConfigurationsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error)) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketIntelligentTieringConfigurations provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketIntelligentTieringConfigurations(_a0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketIntelligentTieringConfigurations")
-	}
-
-	var r0 *s3.ListBucketIntelligentTieringConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketIntelligentTieringConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketIntelligentTieringConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketIntelligentTieringConfigurations'
-type S3API_ListBucketIntelligentTieringConfigurations_Call struct {
-	*mock.Call
-}
-
-// ListBucketIntelligentTieringConfigurations is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketIntelligentTieringConfigurationsInput
-func (_e *S3API_Expecter) ListBucketIntelligentTieringConfigurations(_a0 interface{}) *S3API_ListBucketIntelligentTieringConfigurations_Call {
-	return &S3API_ListBucketIntelligentTieringConfigurations_Call{Call: _e.mock.On("ListBucketIntelligentTieringConfigurations", _a0)}
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurations_Call) Run(run func(_a0 *s3.ListBucketIntelligentTieringConfigurationsInput)) *S3API_ListBucketIntelligentTieringConfigurations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketIntelligentTieringConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurations_Call) Return(_a0 *s3.ListBucketIntelligentTieringConfigurationsOutput, _a1 error) *S3API_ListBucketIntelligentTieringConfigurations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurations_Call) RunAndReturn(run func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)) *S3API_ListBucketIntelligentTieringConfigurations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketIntelligentTieringConfigurationsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketIntelligentTieringConfigurationsRequest(_a0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketIntelligentTieringConfigurationsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListBucketIntelligentTieringConfigurationsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListBucketIntelligentTieringConfigurationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketIntelligentTieringConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketIntelligentTieringConfigurationsRequest'
-type S3API_ListBucketIntelligentTieringConfigurationsRequest_Call struct {
-	*mock.Call
-}
-
-// ListBucketIntelligentTieringConfigurationsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketIntelligentTieringConfigurationsInput
-func (_e *S3API_Expecter) ListBucketIntelligentTieringConfigurationsRequest(_a0 interface{}) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call {
-	return &S3API_ListBucketIntelligentTieringConfigurationsRequest_Call{Call: _e.mock.On("ListBucketIntelligentTieringConfigurationsRequest", _a0)}
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call) Run(run func(_a0 *s3.ListBucketIntelligentTieringConfigurationsInput)) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketIntelligentTieringConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListBucketIntelligentTieringConfigurationsOutput) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call) RunAndReturn(run func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput)) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketIntelligentTieringConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListBucketIntelligentTieringConfigurationsWithContext(_a0 aws.Context, _a1 *s3.ListBucketIntelligentTieringConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketIntelligentTieringConfigurationsWithContext")
-	}
-
-	var r0 *s3.ListBucketIntelligentTieringConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketIntelligentTieringConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketIntelligentTieringConfigurationsWithContext'
-type S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListBucketIntelligentTieringConfigurationsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListBucketIntelligentTieringConfigurationsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListBucketIntelligentTieringConfigurationsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call {
-	return &S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketIntelligentTieringConfigurationsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListBucketIntelligentTieringConfigurationsInput, _a2 ...request.Option)) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListBucketIntelligentTieringConfigurationsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call) Return(_a0 *s3.ListBucketIntelligentTieringConfigurationsOutput, _a1 error) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketInventoryConfigurations provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketInventoryConfigurations(_a0 *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketInventoryConfigurations")
-	}
-
-	var r0 *s3.ListBucketInventoryConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) *s3.ListBucketInventoryConfigurationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketInventoryConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketInventoryConfigurationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketInventoryConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketInventoryConfigurations'
-type S3API_ListBucketInventoryConfigurations_Call struct {
-	*mock.Call
-}
-
-// ListBucketInventoryConfigurations is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketInventoryConfigurationsInput
-func (_e *S3API_Expecter) ListBucketInventoryConfigurations(_a0 interface{}) *S3API_ListBucketInventoryConfigurations_Call {
-	return &S3API_ListBucketInventoryConfigurations_Call{Call: _e.mock.On("ListBucketInventoryConfigurations", _a0)}
-}
-
-func (_c *S3API_ListBucketInventoryConfigurations_Call) Run(run func(_a0 *s3.ListBucketInventoryConfigurationsInput)) *S3API_ListBucketInventoryConfigurations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketInventoryConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketInventoryConfigurations_Call) Return(_a0 *s3.ListBucketInventoryConfigurationsOutput, _a1 error) *S3API_ListBucketInventoryConfigurations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketInventoryConfigurations_Call) RunAndReturn(run func(*s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error)) *S3API_ListBucketInventoryConfigurations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketInventoryConfigurationsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketInventoryConfigurationsRequest(_a0 *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketInventoryConfigurationsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListBucketInventoryConfigurationsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketInventoryConfigurationsInput) *s3.ListBucketInventoryConfigurationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListBucketInventoryConfigurationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketInventoryConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketInventoryConfigurationsRequest'
-type S3API_ListBucketInventoryConfigurationsRequest_Call struct {
-	*mock.Call
-}
-
-// ListBucketInventoryConfigurationsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketInventoryConfigurationsInput
-func (_e *S3API_Expecter) ListBucketInventoryConfigurationsRequest(_a0 interface{}) *S3API_ListBucketInventoryConfigurationsRequest_Call {
-	return &S3API_ListBucketInventoryConfigurationsRequest_Call{Call: _e.mock.On("ListBucketInventoryConfigurationsRequest", _a0)}
-}
-
-func (_c *S3API_ListBucketInventoryConfigurationsRequest_Call) Run(run func(_a0 *s3.ListBucketInventoryConfigurationsInput)) *S3API_ListBucketInventoryConfigurationsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketInventoryConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketInventoryConfigurationsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListBucketInventoryConfigurationsOutput) *S3API_ListBucketInventoryConfigurationsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketInventoryConfigurationsRequest_Call) RunAndReturn(run func(*s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput)) *S3API_ListBucketInventoryConfigurationsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketInventoryConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListBucketInventoryConfigurationsWithContext(_a0 aws.Context, _a1 *s3.ListBucketInventoryConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketInventoryConfigurationsWithContext")
-	}
-
-	var r0 *s3.ListBucketInventoryConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) *s3.ListBucketInventoryConfigurationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketInventoryConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketInventoryConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketInventoryConfigurationsWithContext'
-type S3API_ListBucketInventoryConfigurationsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListBucketInventoryConfigurationsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListBucketInventoryConfigurationsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListBucketInventoryConfigurationsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListBucketInventoryConfigurationsWithContext_Call {
-	return &S3API_ListBucketInventoryConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketInventoryConfigurationsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListBucketInventoryConfigurationsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListBucketInventoryConfigurationsInput, _a2 ...request.Option)) *S3API_ListBucketInventoryConfigurationsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListBucketInventoryConfigurationsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketInventoryConfigurationsWithContext_Call) Return(_a0 *s3.ListBucketInventoryConfigurationsOutput, _a1 error) *S3API_ListBucketInventoryConfigurationsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketInventoryConfigurationsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error)) *S3API_ListBucketInventoryConfigurationsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketMetricsConfigurations provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketMetricsConfigurations(_a0 *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketMetricsConfigurations")
-	}
-
-	var r0 *s3.ListBucketMetricsConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) *s3.ListBucketMetricsConfigurationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketMetricsConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketMetricsConfigurationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketMetricsConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketMetricsConfigurations'
-type S3API_ListBucketMetricsConfigurations_Call struct {
-	*mock.Call
-}
-
-// ListBucketMetricsConfigurations is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketMetricsConfigurationsInput
-func (_e *S3API_Expecter) ListBucketMetricsConfigurations(_a0 interface{}) *S3API_ListBucketMetricsConfigurations_Call {
-	return &S3API_ListBucketMetricsConfigurations_Call{Call: _e.mock.On("ListBucketMetricsConfigurations", _a0)}
-}
-
-func (_c *S3API_ListBucketMetricsConfigurations_Call) Run(run func(_a0 *s3.ListBucketMetricsConfigurationsInput)) *S3API_ListBucketMetricsConfigurations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketMetricsConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketMetricsConfigurations_Call) Return(_a0 *s3.ListBucketMetricsConfigurationsOutput, _a1 error) *S3API_ListBucketMetricsConfigurations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketMetricsConfigurations_Call) RunAndReturn(run func(*s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error)) *S3API_ListBucketMetricsConfigurations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketMetricsConfigurationsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketMetricsConfigurationsRequest(_a0 *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketMetricsConfigurationsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListBucketMetricsConfigurationsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketMetricsConfigurationsInput) *s3.ListBucketMetricsConfigurationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListBucketMetricsConfigurationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketMetricsConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketMetricsConfigurationsRequest'
-type S3API_ListBucketMetricsConfigurationsRequest_Call struct {
-	*mock.Call
-}
-
-// ListBucketMetricsConfigurationsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketMetricsConfigurationsInput
-func (_e *S3API_Expecter) ListBucketMetricsConfigurationsRequest(_a0 interface{}) *S3API_ListBucketMetricsConfigurationsRequest_Call {
-	return &S3API_ListBucketMetricsConfigurationsRequest_Call{Call: _e.mock.On("ListBucketMetricsConfigurationsRequest", _a0)}
-}
-
-func (_c *S3API_ListBucketMetricsConfigurationsRequest_Call) Run(run func(_a0 *s3.ListBucketMetricsConfigurationsInput)) *S3API_ListBucketMetricsConfigurationsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketMetricsConfigurationsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketMetricsConfigurationsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListBucketMetricsConfigurationsOutput) *S3API_ListBucketMetricsConfigurationsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketMetricsConfigurationsRequest_Call) RunAndReturn(run func(*s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput)) *S3API_ListBucketMetricsConfigurationsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketMetricsConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListBucketMetricsConfigurationsWithContext(_a0 aws.Context, _a1 *s3.ListBucketMetricsConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketMetricsConfigurationsWithContext")
-	}
-
-	var r0 *s3.ListBucketMetricsConfigurationsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) *s3.ListBucketMetricsConfigurationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketMetricsConfigurationsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketMetricsConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketMetricsConfigurationsWithContext'
-type S3API_ListBucketMetricsConfigurationsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListBucketMetricsConfigurationsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListBucketMetricsConfigurationsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListBucketMetricsConfigurationsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListBucketMetricsConfigurationsWithContext_Call {
-	return &S3API_ListBucketMetricsConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketMetricsConfigurationsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListBucketMetricsConfigurationsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListBucketMetricsConfigurationsInput, _a2 ...request.Option)) *S3API_ListBucketMetricsConfigurationsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListBucketMetricsConfigurationsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketMetricsConfigurationsWithContext_Call) Return(_a0 *s3.ListBucketMetricsConfigurationsOutput, _a1 error) *S3API_ListBucketMetricsConfigurationsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketMetricsConfigurationsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error)) *S3API_ListBucketMetricsConfigurationsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBuckets provides a mock function with given fields: _a0
-func (_m *S3API) ListBuckets(_a0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBuckets")
-	}
-
-	var r0 *s3.ListBucketsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) *s3.ListBucketsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBuckets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBuckets'
-type S3API_ListBuckets_Call struct {
-	*mock.Call
-}
-
-// ListBuckets is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketsInput
-func (_e *S3API_Expecter) ListBuckets(_a0 interface{}) *S3API_ListBuckets_Call {
-	return &S3API_ListBuckets_Call{Call: _e.mock.On("ListBuckets", _a0)}
-}
-
-func (_c *S3API_ListBuckets_Call) Run(run func(_a0 *s3.ListBucketsInput)) *S3API_ListBuckets_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBuckets_Call) Return(_a0 *s3.ListBucketsOutput, _a1 error) *S3API_ListBuckets_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBuckets_Call) RunAndReturn(run func(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error)) *S3API_ListBuckets_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListBucketsRequest(_a0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListBucketsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListBucketsInput) *s3.ListBucketsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListBucketsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketsRequest'
-type S3API_ListBucketsRequest_Call struct {
-	*mock.Call
-}
-
-// ListBucketsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListBucketsInput
-func (_e *S3API_Expecter) ListBucketsRequest(_a0 interface{}) *S3API_ListBucketsRequest_Call {
-	return &S3API_ListBucketsRequest_Call{Call: _e.mock.On("ListBucketsRequest", _a0)}
-}
-
-func (_c *S3API_ListBucketsRequest_Call) Run(run func(_a0 *s3.ListBucketsInput)) *S3API_ListBucketsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListBucketsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListBucketsOutput) *S3API_ListBucketsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketsRequest_Call) RunAndReturn(run func(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)) *S3API_ListBucketsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListBucketsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListBucketsWithContext(_a0 aws.Context, _a1 *s3.ListBucketsInput, _a2 ...request.Option) (*s3.ListBucketsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListBucketsWithContext")
-	}
-
-	var r0 *s3.ListBucketsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketsInput, ...request.Option) (*s3.ListBucketsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketsInput, ...request.Option) *s3.ListBucketsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListBucketsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListBucketsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketsWithContext'
-type S3API_ListBucketsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListBucketsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListBucketsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListBucketsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListBucketsWithContext_Call {
-	return &S3API_ListBucketsWithContext_Call{Call: _e.mock.On("ListBucketsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListBucketsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListBucketsInput, _a2 ...request.Option)) *S3API_ListBucketsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListBucketsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListBucketsWithContext_Call) Return(_a0 *s3.ListBucketsOutput, _a1 error) *S3API_ListBucketsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListBucketsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListBucketsInput, ...request.Option) (*s3.ListBucketsOutput, error)) *S3API_ListBucketsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListDirectoryBuckets provides a mock function with given fields: _a0
-func (_m *S3API) ListDirectoryBuckets(_a0 *s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListDirectoryBuckets")
-	}
-
-	var r0 *s3.ListDirectoryBucketsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) *s3.ListDirectoryBucketsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListDirectoryBucketsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListDirectoryBucketsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListDirectoryBuckets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBuckets'
-type S3API_ListDirectoryBuckets_Call struct {
-	*mock.Call
-}
-
-// ListDirectoryBuckets is a helper method to define mock.On call
-//   - _a0 *s3.ListDirectoryBucketsInput
-func (_e *S3API_Expecter) ListDirectoryBuckets(_a0 interface{}) *S3API_ListDirectoryBuckets_Call {
-	return &S3API_ListDirectoryBuckets_Call{Call: _e.mock.On("ListDirectoryBuckets", _a0)}
-}
-
-func (_c *S3API_ListDirectoryBuckets_Call) Run(run func(_a0 *s3.ListDirectoryBucketsInput)) *S3API_ListDirectoryBuckets_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListDirectoryBucketsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBuckets_Call) Return(_a0 *s3.ListDirectoryBucketsOutput, _a1 error) *S3API_ListDirectoryBuckets_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBuckets_Call) RunAndReturn(run func(*s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error)) *S3API_ListDirectoryBuckets_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListDirectoryBucketsPages provides a mock function with given fields: _a0, _a1
-func (_m *S3API) ListDirectoryBucketsPages(_a0 *s3.ListDirectoryBucketsInput, _a1 func(*s3.ListDirectoryBucketsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListDirectoryBucketsPages")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListDirectoryBucketsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsPages'
-type S3API_ListDirectoryBucketsPages_Call struct {
-	*mock.Call
-}
-
-// ListDirectoryBucketsPages is a helper method to define mock.On call
-//   - _a0 *s3.ListDirectoryBucketsInput
-//   - _a1 func(*s3.ListDirectoryBucketsOutput , bool) bool
-func (_e *S3API_Expecter) ListDirectoryBucketsPages(_a0 interface{}, _a1 interface{}) *S3API_ListDirectoryBucketsPages_Call {
-	return &S3API_ListDirectoryBucketsPages_Call{Call: _e.mock.On("ListDirectoryBucketsPages", _a0, _a1)}
-}
-
-func (_c *S3API_ListDirectoryBucketsPages_Call) Run(run func(_a0 *s3.ListDirectoryBucketsInput, _a1 func(*s3.ListDirectoryBucketsOutput, bool) bool)) *S3API_ListDirectoryBucketsPages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListDirectoryBucketsInput), args[1].(func(*s3.ListDirectoryBucketsOutput, bool) bool))
-	})
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsPages_Call) Return(_a0 error) *S3API_ListDirectoryBucketsPages_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsPages_Call) RunAndReturn(run func(*s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool) error) *S3API_ListDirectoryBucketsPages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListDirectoryBucketsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *S3API) ListDirectoryBucketsPagesWithContext(_a0 aws.Context, _a1 *s3.ListDirectoryBucketsInput, _a2 func(*s3.ListDirectoryBucketsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListDirectoryBucketsPagesWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListDirectoryBucketsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsPagesWithContext'
-type S3API_ListDirectoryBucketsPagesWithContext_Call struct {
-	*mock.Call
-}
-
-// ListDirectoryBucketsPagesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListDirectoryBucketsInput
-//   - _a2 func(*s3.ListDirectoryBucketsOutput , bool) bool
-//   - _a3 ...request.Option
-func (_e *S3API_Expecter) ListDirectoryBucketsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *S3API_ListDirectoryBucketsPagesWithContext_Call {
-	return &S3API_ListDirectoryBucketsPagesWithContext_Call{Call: _e.mock.On("ListDirectoryBucketsPagesWithContext",
-		append([]interface{}{_a0, _a1, _a2}, _a3...)...)}
-}
-
-func (_c *S3API_ListDirectoryBucketsPagesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListDirectoryBucketsInput, _a2 func(*s3.ListDirectoryBucketsOutput, bool) bool, _a3 ...request.Option)) *S3API_ListDirectoryBucketsPagesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-3)
-		for i, a := range args[3:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListDirectoryBucketsInput), args[2].(func(*s3.ListDirectoryBucketsOutput, bool) bool), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsPagesWithContext_Call) Return(_a0 error) *S3API_ListDirectoryBucketsPagesWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsPagesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool, ...request.Option) error) *S3API_ListDirectoryBucketsPagesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListDirectoryBucketsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListDirectoryBucketsRequest(_a0 *s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListDirectoryBucketsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListDirectoryBucketsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListDirectoryBucketsInput) *s3.ListDirectoryBucketsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListDirectoryBucketsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListDirectoryBucketsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsRequest'
-type S3API_ListDirectoryBucketsRequest_Call struct {
-	*mock.Call
-}
-
-// ListDirectoryBucketsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListDirectoryBucketsInput
-func (_e *S3API_Expecter) ListDirectoryBucketsRequest(_a0 interface{}) *S3API_ListDirectoryBucketsRequest_Call {
-	return &S3API_ListDirectoryBucketsRequest_Call{Call: _e.mock.On("ListDirectoryBucketsRequest", _a0)}
-}
-
-func (_c *S3API_ListDirectoryBucketsRequest_Call) Run(run func(_a0 *s3.ListDirectoryBucketsInput)) *S3API_ListDirectoryBucketsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListDirectoryBucketsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListDirectoryBucketsOutput) *S3API_ListDirectoryBucketsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsRequest_Call) RunAndReturn(run func(*s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput)) *S3API_ListDirectoryBucketsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListDirectoryBucketsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListDirectoryBucketsWithContext(_a0 aws.Context, _a1 *s3.ListDirectoryBucketsInput, _a2 ...request.Option) (*s3.ListDirectoryBucketsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListDirectoryBucketsWithContext")
-	}
-
-	var r0 *s3.ListDirectoryBucketsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) (*s3.ListDirectoryBucketsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) *s3.ListDirectoryBucketsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListDirectoryBucketsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListDirectoryBucketsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsWithContext'
-type S3API_ListDirectoryBucketsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListDirectoryBucketsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListDirectoryBucketsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListDirectoryBucketsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListDirectoryBucketsWithContext_Call {
-	return &S3API_ListDirectoryBucketsWithContext_Call{Call: _e.mock.On("ListDirectoryBucketsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListDirectoryBucketsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListDirectoryBucketsInput, _a2 ...request.Option)) *S3API_ListDirectoryBucketsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListDirectoryBucketsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsWithContext_Call) Return(_a0 *s3.ListDirectoryBucketsOutput, _a1 error) *S3API_ListDirectoryBucketsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListDirectoryBucketsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) (*s3.ListDirectoryBucketsOutput, error)) *S3API_ListDirectoryBucketsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListMultipartUploads provides a mock function with given fields: _a0
-func (_m *S3API) ListMultipartUploads(_a0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListMultipartUploads")
-	}
-
-	var r0 *s3.ListMultipartUploadsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) *s3.ListMultipartUploadsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListMultipartUploadsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListMultipartUploadsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListMultipartUploads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploads'
-type S3API_ListMultipartUploads_Call struct {
-	*mock.Call
-}
-
-// ListMultipartUploads is a helper method to define mock.On call
-//   - _a0 *s3.ListMultipartUploadsInput
-func (_e *S3API_Expecter) ListMultipartUploads(_a0 interface{}) *S3API_ListMultipartUploads_Call {
-	return &S3API_ListMultipartUploads_Call{Call: _e.mock.On("ListMultipartUploads", _a0)}
-}
-
-func (_c *S3API_ListMultipartUploads_Call) Run(run func(_a0 *s3.ListMultipartUploadsInput)) *S3API_ListMultipartUploads_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListMultipartUploadsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploads_Call) Return(_a0 *s3.ListMultipartUploadsOutput, _a1 error) *S3API_ListMultipartUploads_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploads_Call) RunAndReturn(run func(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)) *S3API_ListMultipartUploads_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListMultipartUploadsPages provides a mock function with given fields: _a0, _a1
-func (_m *S3API) ListMultipartUploadsPages(_a0 *s3.ListMultipartUploadsInput, _a1 func(*s3.ListMultipartUploadsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListMultipartUploadsPages")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListMultipartUploadsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsPages'
-type S3API_ListMultipartUploadsPages_Call struct {
-	*mock.Call
-}
-
-// ListMultipartUploadsPages is a helper method to define mock.On call
-//   - _a0 *s3.ListMultipartUploadsInput
-//   - _a1 func(*s3.ListMultipartUploadsOutput , bool) bool
-func (_e *S3API_Expecter) ListMultipartUploadsPages(_a0 interface{}, _a1 interface{}) *S3API_ListMultipartUploadsPages_Call {
-	return &S3API_ListMultipartUploadsPages_Call{Call: _e.mock.On("ListMultipartUploadsPages", _a0, _a1)}
-}
-
-func (_c *S3API_ListMultipartUploadsPages_Call) Run(run func(_a0 *s3.ListMultipartUploadsInput, _a1 func(*s3.ListMultipartUploadsOutput, bool) bool)) *S3API_ListMultipartUploadsPages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListMultipartUploadsInput), args[1].(func(*s3.ListMultipartUploadsOutput, bool) bool))
-	})
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsPages_Call) Return(_a0 error) *S3API_ListMultipartUploadsPages_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsPages_Call) RunAndReturn(run func(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error) *S3API_ListMultipartUploadsPages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListMultipartUploadsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *S3API) ListMultipartUploadsPagesWithContext(_a0 aws.Context, _a1 *s3.ListMultipartUploadsInput, _a2 func(*s3.ListMultipartUploadsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListMultipartUploadsPagesWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListMultipartUploadsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsPagesWithContext'
-type S3API_ListMultipartUploadsPagesWithContext_Call struct {
-	*mock.Call
-}
-
-// ListMultipartUploadsPagesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListMultipartUploadsInput
-//   - _a2 func(*s3.ListMultipartUploadsOutput , bool) bool
-//   - _a3 ...request.Option
-func (_e *S3API_Expecter) ListMultipartUploadsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *S3API_ListMultipartUploadsPagesWithContext_Call {
-	return &S3API_ListMultipartUploadsPagesWithContext_Call{Call: _e.mock.On("ListMultipartUploadsPagesWithContext",
-		append([]interface{}{_a0, _a1, _a2}, _a3...)...)}
-}
-
-func (_c *S3API_ListMultipartUploadsPagesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListMultipartUploadsInput, _a2 func(*s3.ListMultipartUploadsOutput, bool) bool, _a3 ...request.Option)) *S3API_ListMultipartUploadsPagesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-3)
-		for i, a := range args[3:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListMultipartUploadsInput), args[2].(func(*s3.ListMultipartUploadsOutput, bool) bool), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsPagesWithContext_Call) Return(_a0 error) *S3API_ListMultipartUploadsPagesWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsPagesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, ...request.Option) error) *S3API_ListMultipartUploadsPagesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListMultipartUploadsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListMultipartUploadsRequest(_a0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListMultipartUploadsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListMultipartUploadsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListMultipartUploadsInput) *s3.ListMultipartUploadsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListMultipartUploadsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListMultipartUploadsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsRequest'
-type S3API_ListMultipartUploadsRequest_Call struct {
-	*mock.Call
-}
-
-// ListMultipartUploadsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListMultipartUploadsInput
-func (_e *S3API_Expecter) ListMultipartUploadsRequest(_a0 interface{}) *S3API_ListMultipartUploadsRequest_Call {
-	return &S3API_ListMultipartUploadsRequest_Call{Call: _e.mock.On("ListMultipartUploadsRequest", _a0)}
-}
-
-func (_c *S3API_ListMultipartUploadsRequest_Call) Run(run func(_a0 *s3.ListMultipartUploadsInput)) *S3API_ListMultipartUploadsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListMultipartUploadsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListMultipartUploadsOutput) *S3API_ListMultipartUploadsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsRequest_Call) RunAndReturn(run func(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)) *S3API_ListMultipartUploadsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListMultipartUploadsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListMultipartUploadsWithContext(_a0 aws.Context, _a1 *s3.ListMultipartUploadsInput, _a2 ...request.Option) (*s3.ListMultipartUploadsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListMultipartUploadsWithContext")
-	}
-
-	var r0 *s3.ListMultipartUploadsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) (*s3.ListMultipartUploadsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) *s3.ListMultipartUploadsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListMultipartUploadsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListMultipartUploadsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsWithContext'
-type S3API_ListMultipartUploadsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListMultipartUploadsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListMultipartUploadsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListMultipartUploadsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListMultipartUploadsWithContext_Call {
-	return &S3API_ListMultipartUploadsWithContext_Call{Call: _e.mock.On("ListMultipartUploadsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListMultipartUploadsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListMultipartUploadsInput, _a2 ...request.Option)) *S3API_ListMultipartUploadsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListMultipartUploadsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsWithContext_Call) Return(_a0 *s3.ListMultipartUploadsOutput, _a1 error) *S3API_ListMultipartUploadsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListMultipartUploadsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) (*s3.ListMultipartUploadsOutput, error)) *S3API_ListMultipartUploadsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectVersions provides a mock function with given fields: _a0
-func (_m *S3API) ListObjectVersions(_a0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectVersions")
-	}
-
-	var r0 *s3.ListObjectVersionsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) *s3.ListObjectVersionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListObjectVersionsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListObjectVersionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersions'
-type S3API_ListObjectVersions_Call struct {
-	*mock.Call
-}
-
-// ListObjectVersions is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectVersionsInput
-func (_e *S3API_Expecter) ListObjectVersions(_a0 interface{}) *S3API_ListObjectVersions_Call {
-	return &S3API_ListObjectVersions_Call{Call: _e.mock.On("ListObjectVersions", _a0)}
-}
-
-func (_c *S3API_ListObjectVersions_Call) Run(run func(_a0 *s3.ListObjectVersionsInput)) *S3API_ListObjectVersions_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectVersionsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectVersions_Call) Return(_a0 *s3.ListObjectVersionsOutput, _a1 error) *S3API_ListObjectVersions_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectVersions_Call) RunAndReturn(run func(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)) *S3API_ListObjectVersions_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectVersionsPages provides a mock function with given fields: _a0, _a1
-func (_m *S3API) ListObjectVersionsPages(_a0 *s3.ListObjectVersionsInput, _a1 func(*s3.ListObjectVersionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectVersionsPages")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListObjectVersionsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsPages'
-type S3API_ListObjectVersionsPages_Call struct {
-	*mock.Call
-}
-
-// ListObjectVersionsPages is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectVersionsInput
-//   - _a1 func(*s3.ListObjectVersionsOutput , bool) bool
-func (_e *S3API_Expecter) ListObjectVersionsPages(_a0 interface{}, _a1 interface{}) *S3API_ListObjectVersionsPages_Call {
-	return &S3API_ListObjectVersionsPages_Call{Call: _e.mock.On("ListObjectVersionsPages", _a0, _a1)}
-}
-
-func (_c *S3API_ListObjectVersionsPages_Call) Run(run func(_a0 *s3.ListObjectVersionsInput, _a1 func(*s3.ListObjectVersionsOutput, bool) bool)) *S3API_ListObjectVersionsPages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectVersionsInput), args[1].(func(*s3.ListObjectVersionsOutput, bool) bool))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsPages_Call) Return(_a0 error) *S3API_ListObjectVersionsPages_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsPages_Call) RunAndReturn(run func(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error) *S3API_ListObjectVersionsPages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *S3API) ListObjectVersionsPagesWithContext(_a0 aws.Context, _a1 *s3.ListObjectVersionsInput, _a2 func(*s3.ListObjectVersionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectVersionsPagesWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListObjectVersionsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsPagesWithContext'
-type S3API_ListObjectVersionsPagesWithContext_Call struct {
-	*mock.Call
-}
-
-// ListObjectVersionsPagesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListObjectVersionsInput
-//   - _a2 func(*s3.ListObjectVersionsOutput , bool) bool
-//   - _a3 ...request.Option
-func (_e *S3API_Expecter) ListObjectVersionsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *S3API_ListObjectVersionsPagesWithContext_Call {
-	return &S3API_ListObjectVersionsPagesWithContext_Call{Call: _e.mock.On("ListObjectVersionsPagesWithContext",
-		append([]interface{}{_a0, _a1, _a2}, _a3...)...)}
-}
-
-func (_c *S3API_ListObjectVersionsPagesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListObjectVersionsInput, _a2 func(*s3.ListObjectVersionsOutput, bool) bool, _a3 ...request.Option)) *S3API_ListObjectVersionsPagesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-3)
-		for i, a := range args[3:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListObjectVersionsInput), args[2].(func(*s3.ListObjectVersionsOutput, bool) bool), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsPagesWithContext_Call) Return(_a0 error) *S3API_ListObjectVersionsPagesWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsPagesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, ...request.Option) error) *S3API_ListObjectVersionsPagesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectVersionsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListObjectVersionsRequest(_a0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectVersionsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListObjectVersionsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListObjectVersionsInput) *s3.ListObjectVersionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListObjectVersionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectVersionsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsRequest'
-type S3API_ListObjectVersionsRequest_Call struct {
-	*mock.Call
-}
-
-// ListObjectVersionsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectVersionsInput
-func (_e *S3API_Expecter) ListObjectVersionsRequest(_a0 interface{}) *S3API_ListObjectVersionsRequest_Call {
-	return &S3API_ListObjectVersionsRequest_Call{Call: _e.mock.On("ListObjectVersionsRequest", _a0)}
-}
-
-func (_c *S3API_ListObjectVersionsRequest_Call) Run(run func(_a0 *s3.ListObjectVersionsInput)) *S3API_ListObjectVersionsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectVersionsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListObjectVersionsOutput) *S3API_ListObjectVersionsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsRequest_Call) RunAndReturn(run func(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)) *S3API_ListObjectVersionsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListObjectVersionsWithContext(_a0 aws.Context, _a1 *s3.ListObjectVersionsInput, _a2 ...request.Option) (*s3.ListObjectVersionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectVersionsWithContext")
-	}
-
-	var r0 *s3.ListObjectVersionsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) (*s3.ListObjectVersionsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) *s3.ListObjectVersionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListObjectVersionsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectVersionsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsWithContext'
-type S3API_ListObjectVersionsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListObjectVersionsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListObjectVersionsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListObjectVersionsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListObjectVersionsWithContext_Call {
-	return &S3API_ListObjectVersionsWithContext_Call{Call: _e.mock.On("ListObjectVersionsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListObjectVersionsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListObjectVersionsInput, _a2 ...request.Option)) *S3API_ListObjectVersionsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListObjectVersionsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsWithContext_Call) Return(_a0 *s3.ListObjectVersionsOutput, _a1 error) *S3API_ListObjectVersionsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectVersionsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) (*s3.ListObjectVersionsOutput, error)) *S3API_ListObjectVersionsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjects provides a mock function with given fields: _a0
-func (_m *S3API) ListObjects(_a0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjects")
-	}
-
-	var r0 *s3.ListObjectsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) *s3.ListObjectsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListObjectsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListObjectsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjects'
-type S3API_ListObjects_Call struct {
-	*mock.Call
-}
-
-// ListObjects is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectsInput
-func (_e *S3API_Expecter) ListObjects(_a0 interface{}) *S3API_ListObjects_Call {
-	return &S3API_ListObjects_Call{Call: _e.mock.On("ListObjects", _a0)}
-}
-
-func (_c *S3API_ListObjects_Call) Run(run func(_a0 *s3.ListObjectsInput)) *S3API_ListObjects_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjects_Call) Return(_a0 *s3.ListObjectsOutput, _a1 error) *S3API_ListObjects_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjects_Call) RunAndReturn(run func(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error)) *S3API_ListObjects_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsPages provides a mock function with given fields: _a0, _a1
-func (_m *S3API) ListObjectsPages(_a0 *s3.ListObjectsInput, _a1 func(*s3.ListObjectsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsPages")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListObjectsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsPages'
-type S3API_ListObjectsPages_Call struct {
-	*mock.Call
-}
-
-// ListObjectsPages is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectsInput
-//   - _a1 func(*s3.ListObjectsOutput , bool) bool
-func (_e *S3API_Expecter) ListObjectsPages(_a0 interface{}, _a1 interface{}) *S3API_ListObjectsPages_Call {
-	return &S3API_ListObjectsPages_Call{Call: _e.mock.On("ListObjectsPages", _a0, _a1)}
-}
-
-func (_c *S3API_ListObjectsPages_Call) Run(run func(_a0 *s3.ListObjectsInput, _a1 func(*s3.ListObjectsOutput, bool) bool)) *S3API_ListObjectsPages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectsInput), args[1].(func(*s3.ListObjectsOutput, bool) bool))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsPages_Call) Return(_a0 error) *S3API_ListObjectsPages_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListObjectsPages_Call) RunAndReturn(run func(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error) *S3API_ListObjectsPages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *S3API) ListObjectsPagesWithContext(_a0 aws.Context, _a1 *s3.ListObjectsInput, _a2 func(*s3.ListObjectsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsPagesWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListObjectsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsPagesWithContext'
-type S3API_ListObjectsPagesWithContext_Call struct {
-	*mock.Call
-}
-
-// ListObjectsPagesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListObjectsInput
-//   - _a2 func(*s3.ListObjectsOutput , bool) bool
-//   - _a3 ...request.Option
-func (_e *S3API_Expecter) ListObjectsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *S3API_ListObjectsPagesWithContext_Call {
-	return &S3API_ListObjectsPagesWithContext_Call{Call: _e.mock.On("ListObjectsPagesWithContext",
-		append([]interface{}{_a0, _a1, _a2}, _a3...)...)}
-}
-
-func (_c *S3API_ListObjectsPagesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListObjectsInput, _a2 func(*s3.ListObjectsOutput, bool) bool, _a3 ...request.Option)) *S3API_ListObjectsPagesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-3)
-		for i, a := range args[3:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListObjectsInput), args[2].(func(*s3.ListObjectsOutput, bool) bool), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsPagesWithContext_Call) Return(_a0 error) *S3API_ListObjectsPagesWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListObjectsPagesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, ...request.Option) error) *S3API_ListObjectsPagesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListObjectsRequest(_a0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListObjectsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListObjectsInput) *s3.ListObjectsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListObjectsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsRequest'
-type S3API_ListObjectsRequest_Call struct {
-	*mock.Call
-}
-
-// ListObjectsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectsInput
-func (_e *S3API_Expecter) ListObjectsRequest(_a0 interface{}) *S3API_ListObjectsRequest_Call {
-	return &S3API_ListObjectsRequest_Call{Call: _e.mock.On("ListObjectsRequest", _a0)}
-}
-
-func (_c *S3API_ListObjectsRequest_Call) Run(run func(_a0 *s3.ListObjectsInput)) *S3API_ListObjectsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListObjectsOutput) *S3API_ListObjectsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectsRequest_Call) RunAndReturn(run func(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)) *S3API_ListObjectsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsV2 provides a mock function with given fields: _a0
-func (_m *S3API) ListObjectsV2(_a0 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsV2")
-	}
-
-	var r0 *s3.ListObjectsV2Output
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) *s3.ListObjectsV2Output); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListObjectsV2Output)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListObjectsV2Input) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectsV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2'
-type S3API_ListObjectsV2_Call struct {
-	*mock.Call
-}
-
-// ListObjectsV2 is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectsV2Input
-func (_e *S3API_Expecter) ListObjectsV2(_a0 interface{}) *S3API_ListObjectsV2_Call {
-	return &S3API_ListObjectsV2_Call{Call: _e.mock.On("ListObjectsV2", _a0)}
-}
-
-func (_c *S3API_ListObjectsV2_Call) Run(run func(_a0 *s3.ListObjectsV2Input)) *S3API_ListObjectsV2_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectsV2Input))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2_Call) Return(_a0 *s3.ListObjectsV2Output, _a1 error) *S3API_ListObjectsV2_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2_Call) RunAndReturn(run func(*s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)) *S3API_ListObjectsV2_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsV2Pages provides a mock function with given fields: _a0, _a1
-func (_m *S3API) ListObjectsV2Pages(_a0 *s3.ListObjectsV2Input, _a1 func(*s3.ListObjectsV2Output, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsV2Pages")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListObjectsV2Pages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2Pages'
-type S3API_ListObjectsV2Pages_Call struct {
-	*mock.Call
-}
-
-// ListObjectsV2Pages is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectsV2Input
-//   - _a1 func(*s3.ListObjectsV2Output , bool) bool
-func (_e *S3API_Expecter) ListObjectsV2Pages(_a0 interface{}, _a1 interface{}) *S3API_ListObjectsV2Pages_Call {
-	return &S3API_ListObjectsV2Pages_Call{Call: _e.mock.On("ListObjectsV2Pages", _a0, _a1)}
-}
-
-func (_c *S3API_ListObjectsV2Pages_Call) Run(run func(_a0 *s3.ListObjectsV2Input, _a1 func(*s3.ListObjectsV2Output, bool) bool)) *S3API_ListObjectsV2Pages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectsV2Input), args[1].(func(*s3.ListObjectsV2Output, bool) bool))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2Pages_Call) Return(_a0 error) *S3API_ListObjectsV2Pages_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2Pages_Call) RunAndReturn(run func(*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) error) *S3API_ListObjectsV2Pages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsV2PagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *S3API) ListObjectsV2PagesWithContext(_a0 aws.Context, _a1 *s3.ListObjectsV2Input, _a2 func(*s3.ListObjectsV2Output, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsV2PagesWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListObjectsV2PagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2PagesWithContext'
-type S3API_ListObjectsV2PagesWithContext_Call struct {
-	*mock.Call
-}
-
-// ListObjectsV2PagesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListObjectsV2Input
-//   - _a2 func(*s3.ListObjectsV2Output , bool) bool
-//   - _a3 ...request.Option
-func (_e *S3API_Expecter) ListObjectsV2PagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *S3API_ListObjectsV2PagesWithContext_Call {
-	return &S3API_ListObjectsV2PagesWithContext_Call{Call: _e.mock.On("ListObjectsV2PagesWithContext",
-		append([]interface{}{_a0, _a1, _a2}, _a3...)...)}
-}
-
-func (_c *S3API_ListObjectsV2PagesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListObjectsV2Input, _a2 func(*s3.ListObjectsV2Output, bool) bool, _a3 ...request.Option)) *S3API_ListObjectsV2PagesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-3)
-		for i, a := range args[3:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListObjectsV2Input), args[2].(func(*s3.ListObjectsV2Output, bool) bool), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2PagesWithContext_Call) Return(_a0 error) *S3API_ListObjectsV2PagesWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2PagesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, ...request.Option) error) *S3API_ListObjectsV2PagesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsV2Request provides a mock function with given fields: _a0
-func (_m *S3API) ListObjectsV2Request(_a0 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsV2Request")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListObjectsV2Output
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListObjectsV2Input) *s3.ListObjectsV2Output); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListObjectsV2Output)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectsV2Request_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2Request'
-type S3API_ListObjectsV2Request_Call struct {
-	*mock.Call
-}
-
-// ListObjectsV2Request is a helper method to define mock.On call
-//   - _a0 *s3.ListObjectsV2Input
-func (_e *S3API_Expecter) ListObjectsV2Request(_a0 interface{}) *S3API_ListObjectsV2Request_Call {
-	return &S3API_ListObjectsV2Request_Call{Call: _e.mock.On("ListObjectsV2Request", _a0)}
-}
-
-func (_c *S3API_ListObjectsV2Request_Call) Run(run func(_a0 *s3.ListObjectsV2Input)) *S3API_ListObjectsV2Request_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListObjectsV2Input))
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2Request_Call) Return(_a0 *request.Request, _a1 *s3.ListObjectsV2Output) *S3API_ListObjectsV2Request_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2Request_Call) RunAndReturn(run func(*s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output)) *S3API_ListObjectsV2Request_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsV2WithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListObjectsV2WithContext(_a0 aws.Context, _a1 *s3.ListObjectsV2Input, _a2 ...request.Option) (*s3.ListObjectsV2Output, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsV2WithContext")
-	}
-
-	var r0 *s3.ListObjectsV2Output
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) (*s3.ListObjectsV2Output, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) *s3.ListObjectsV2Output); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListObjectsV2Output)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectsV2WithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2WithContext'
-type S3API_ListObjectsV2WithContext_Call struct {
-	*mock.Call
-}
-
-// ListObjectsV2WithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListObjectsV2Input
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListObjectsV2WithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListObjectsV2WithContext_Call {
-	return &S3API_ListObjectsV2WithContext_Call{Call: _e.mock.On("ListObjectsV2WithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListObjectsV2WithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListObjectsV2Input, _a2 ...request.Option)) *S3API_ListObjectsV2WithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListObjectsV2Input), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2WithContext_Call) Return(_a0 *s3.ListObjectsV2Output, _a1 error) *S3API_ListObjectsV2WithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectsV2WithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) (*s3.ListObjectsV2Output, error)) *S3API_ListObjectsV2WithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListObjectsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListObjectsWithContext(_a0 aws.Context, _a1 *s3.ListObjectsInput, _a2 ...request.Option) (*s3.ListObjectsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListObjectsWithContext")
-	}
-
-	var r0 *s3.ListObjectsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsInput, ...request.Option) (*s3.ListObjectsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsInput, ...request.Option) *s3.ListObjectsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListObjectsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListObjectsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListObjectsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsWithContext'
-type S3API_ListObjectsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListObjectsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListObjectsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListObjectsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListObjectsWithContext_Call {
-	return &S3API_ListObjectsWithContext_Call{Call: _e.mock.On("ListObjectsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListObjectsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListObjectsInput, _a2 ...request.Option)) *S3API_ListObjectsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListObjectsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListObjectsWithContext_Call) Return(_a0 *s3.ListObjectsOutput, _a1 error) *S3API_ListObjectsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListObjectsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListObjectsInput, ...request.Option) (*s3.ListObjectsOutput, error)) *S3API_ListObjectsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListParts provides a mock function with given fields: _a0
-func (_m *S3API) ListParts(_a0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListParts")
-	}
-
-	var r0 *s3.ListPartsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) (*s3.ListPartsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) *s3.ListPartsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListPartsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListPartsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListParts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListParts'
-type S3API_ListParts_Call struct {
-	*mock.Call
-}
-
-// ListParts is a helper method to define mock.On call
-//   - _a0 *s3.ListPartsInput
-func (_e *S3API_Expecter) ListParts(_a0 interface{}) *S3API_ListParts_Call {
-	return &S3API_ListParts_Call{Call: _e.mock.On("ListParts", _a0)}
-}
-
-func (_c *S3API_ListParts_Call) Run(run func(_a0 *s3.ListPartsInput)) *S3API_ListParts_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListPartsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListParts_Call) Return(_a0 *s3.ListPartsOutput, _a1 error) *S3API_ListParts_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListParts_Call) RunAndReturn(run func(*s3.ListPartsInput) (*s3.ListPartsOutput, error)) *S3API_ListParts_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListPartsPages provides a mock function with given fields: _a0, _a1
-func (_m *S3API) ListPartsPages(_a0 *s3.ListPartsInput, _a1 func(*s3.ListPartsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListPartsPages")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListPartsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsPages'
-type S3API_ListPartsPages_Call struct {
-	*mock.Call
-}
-
-// ListPartsPages is a helper method to define mock.On call
-//   - _a0 *s3.ListPartsInput
-//   - _a1 func(*s3.ListPartsOutput , bool) bool
-func (_e *S3API_Expecter) ListPartsPages(_a0 interface{}, _a1 interface{}) *S3API_ListPartsPages_Call {
-	return &S3API_ListPartsPages_Call{Call: _e.mock.On("ListPartsPages", _a0, _a1)}
-}
-
-func (_c *S3API_ListPartsPages_Call) Run(run func(_a0 *s3.ListPartsInput, _a1 func(*s3.ListPartsOutput, bool) bool)) *S3API_ListPartsPages_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListPartsInput), args[1].(func(*s3.ListPartsOutput, bool) bool))
-	})
-	return _c
-}
-
-func (_c *S3API_ListPartsPages_Call) Return(_a0 error) *S3API_ListPartsPages_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListPartsPages_Call) RunAndReturn(run func(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error) *S3API_ListPartsPages_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListPartsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *S3API) ListPartsPagesWithContext(_a0 aws.Context, _a1 *s3.ListPartsInput, _a2 func(*s3.ListPartsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListPartsPagesWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_ListPartsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsPagesWithContext'
-type S3API_ListPartsPagesWithContext_Call struct {
-	*mock.Call
-}
-
-// ListPartsPagesWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListPartsInput
-//   - _a2 func(*s3.ListPartsOutput , bool) bool
-//   - _a3 ...request.Option
-func (_e *S3API_Expecter) ListPartsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *S3API_ListPartsPagesWithContext_Call {
-	return &S3API_ListPartsPagesWithContext_Call{Call: _e.mock.On("ListPartsPagesWithContext",
-		append([]interface{}{_a0, _a1, _a2}, _a3...)...)}
-}
-
-func (_c *S3API_ListPartsPagesWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListPartsInput, _a2 func(*s3.ListPartsOutput, bool) bool, _a3 ...request.Option)) *S3API_ListPartsPagesWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-3)
-		for i, a := range args[3:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListPartsInput), args[2].(func(*s3.ListPartsOutput, bool) bool), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListPartsPagesWithContext_Call) Return(_a0 error) *S3API_ListPartsPagesWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_ListPartsPagesWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, ...request.Option) error) *S3API_ListPartsPagesWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListPartsRequest provides a mock function with given fields: _a0
-func (_m *S3API) ListPartsRequest(_a0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListPartsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.ListPartsOutput
-	if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.ListPartsInput) *s3.ListPartsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.ListPartsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_ListPartsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsRequest'
-type S3API_ListPartsRequest_Call struct {
-	*mock.Call
-}
-
-// ListPartsRequest is a helper method to define mock.On call
-//   - _a0 *s3.ListPartsInput
-func (_e *S3API_Expecter) ListPartsRequest(_a0 interface{}) *S3API_ListPartsRequest_Call {
-	return &S3API_ListPartsRequest_Call{Call: _e.mock.On("ListPartsRequest", _a0)}
-}
-
-func (_c *S3API_ListPartsRequest_Call) Run(run func(_a0 *s3.ListPartsInput)) *S3API_ListPartsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.ListPartsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_ListPartsRequest_Call) Return(_a0 *request.Request, _a1 *s3.ListPartsOutput) *S3API_ListPartsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListPartsRequest_Call) RunAndReturn(run func(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)) *S3API_ListPartsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ListPartsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) ListPartsWithContext(_a0 aws.Context, _a1 *s3.ListPartsInput, _a2 ...request.Option) (*s3.ListPartsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ListPartsWithContext")
-	}
-
-	var r0 *s3.ListPartsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListPartsInput, ...request.Option) (*s3.ListPartsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.ListPartsInput, ...request.Option) *s3.ListPartsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.ListPartsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.ListPartsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_ListPartsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsWithContext'
-type S3API_ListPartsWithContext_Call struct {
-	*mock.Call
-}
-
-// ListPartsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.ListPartsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) ListPartsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_ListPartsWithContext_Call {
-	return &S3API_ListPartsWithContext_Call{Call: _e.mock.On("ListPartsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_ListPartsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.ListPartsInput, _a2 ...request.Option)) *S3API_ListPartsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.ListPartsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_ListPartsWithContext_Call) Return(_a0 *s3.ListPartsOutput, _a1 error) *S3API_ListPartsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_ListPartsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.ListPartsInput, ...request.Option) (*s3.ListPartsOutput, error)) *S3API_ListPartsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAccelerateConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketAccelerateConfiguration(_a0 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAccelerateConfiguration")
-	}
-
-	var r0 *s3.PutBucketAccelerateConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) *s3.PutBucketAccelerateConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketAccelerateConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketAccelerateConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAccelerateConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAccelerateConfiguration'
-type S3API_PutBucketAccelerateConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketAccelerateConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketAccelerateConfigurationInput
-func (_e *S3API_Expecter) PutBucketAccelerateConfiguration(_a0 interface{}) *S3API_PutBucketAccelerateConfiguration_Call {
-	return &S3API_PutBucketAccelerateConfiguration_Call{Call: _e.mock.On("PutBucketAccelerateConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketAccelerateConfiguration_Call) Run(run func(_a0 *s3.PutBucketAccelerateConfigurationInput)) *S3API_PutBucketAccelerateConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketAccelerateConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAccelerateConfiguration_Call) Return(_a0 *s3.PutBucketAccelerateConfigurationOutput, _a1 error) *S3API_PutBucketAccelerateConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAccelerateConfiguration_Call) RunAndReturn(run func(*s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error)) *S3API_PutBucketAccelerateConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAccelerateConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketAccelerateConfigurationRequest(_a0 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAccelerateConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketAccelerateConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketAccelerateConfigurationInput) *s3.PutBucketAccelerateConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketAccelerateConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAccelerateConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAccelerateConfigurationRequest'
-type S3API_PutBucketAccelerateConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketAccelerateConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketAccelerateConfigurationInput
-func (_e *S3API_Expecter) PutBucketAccelerateConfigurationRequest(_a0 interface{}) *S3API_PutBucketAccelerateConfigurationRequest_Call {
-	return &S3API_PutBucketAccelerateConfigurationRequest_Call{Call: _e.mock.On("PutBucketAccelerateConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketAccelerateConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketAccelerateConfigurationInput)) *S3API_PutBucketAccelerateConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketAccelerateConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAccelerateConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketAccelerateConfigurationOutput) *S3API_PutBucketAccelerateConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAccelerateConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput)) *S3API_PutBucketAccelerateConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAccelerateConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketAccelerateConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketAccelerateConfigurationInput, _a2 ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAccelerateConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketAccelerateConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) *s3.PutBucketAccelerateConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketAccelerateConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAccelerateConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAccelerateConfigurationWithContext'
-type S3API_PutBucketAccelerateConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketAccelerateConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketAccelerateConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketAccelerateConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketAccelerateConfigurationWithContext_Call {
-	return &S3API_PutBucketAccelerateConfigurationWithContext_Call{Call: _e.mock.On("PutBucketAccelerateConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketAccelerateConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketAccelerateConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketAccelerateConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketAccelerateConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAccelerateConfigurationWithContext_Call) Return(_a0 *s3.PutBucketAccelerateConfigurationOutput, _a1 error) *S3API_PutBucketAccelerateConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAccelerateConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error)) *S3API_PutBucketAccelerateConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAcl provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketAcl(_a0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAcl")
-	}
-
-	var r0 *s3.PutBucketAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) *s3.PutBucketAclOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketAclInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAcl'
-type S3API_PutBucketAcl_Call struct {
-	*mock.Call
-}
-
-// PutBucketAcl is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketAclInput
-func (_e *S3API_Expecter) PutBucketAcl(_a0 interface{}) *S3API_PutBucketAcl_Call {
-	return &S3API_PutBucketAcl_Call{Call: _e.mock.On("PutBucketAcl", _a0)}
-}
-
-func (_c *S3API_PutBucketAcl_Call) Run(run func(_a0 *s3.PutBucketAclInput)) *S3API_PutBucketAcl_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAcl_Call) Return(_a0 *s3.PutBucketAclOutput, _a1 error) *S3API_PutBucketAcl_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAcl_Call) RunAndReturn(run func(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)) *S3API_PutBucketAcl_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAclRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketAclRequest(_a0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAclRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketAclOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketAclInput) *s3.PutBucketAclOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketAclOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAclRequest'
-type S3API_PutBucketAclRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketAclRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketAclInput
-func (_e *S3API_Expecter) PutBucketAclRequest(_a0 interface{}) *S3API_PutBucketAclRequest_Call {
-	return &S3API_PutBucketAclRequest_Call{Call: _e.mock.On("PutBucketAclRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketAclRequest_Call) Run(run func(_a0 *s3.PutBucketAclInput)) *S3API_PutBucketAclRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAclRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketAclOutput) *S3API_PutBucketAclRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAclRequest_Call) RunAndReturn(run func(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)) *S3API_PutBucketAclRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAclWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketAclWithContext(_a0 aws.Context, _a1 *s3.PutBucketAclInput, _a2 ...request.Option) (*s3.PutBucketAclOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAclWithContext")
-	}
-
-	var r0 *s3.PutBucketAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAclInput, ...request.Option) (*s3.PutBucketAclOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAclInput, ...request.Option) *s3.PutBucketAclOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketAclInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAclWithContext'
-type S3API_PutBucketAclWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketAclWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketAclInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketAclWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketAclWithContext_Call {
-	return &S3API_PutBucketAclWithContext_Call{Call: _e.mock.On("PutBucketAclWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketAclWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketAclInput, _a2 ...request.Option)) *S3API_PutBucketAclWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketAclInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAclWithContext_Call) Return(_a0 *s3.PutBucketAclOutput, _a1 error) *S3API_PutBucketAclWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAclWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketAclInput, ...request.Option) (*s3.PutBucketAclOutput, error)) *S3API_PutBucketAclWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAnalyticsConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketAnalyticsConfiguration(_a0 *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAnalyticsConfiguration")
-	}
-
-	var r0 *s3.PutBucketAnalyticsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) *s3.PutBucketAnalyticsConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketAnalyticsConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAnalyticsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAnalyticsConfiguration'
-type S3API_PutBucketAnalyticsConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketAnalyticsConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketAnalyticsConfigurationInput
-func (_e *S3API_Expecter) PutBucketAnalyticsConfiguration(_a0 interface{}) *S3API_PutBucketAnalyticsConfiguration_Call {
-	return &S3API_PutBucketAnalyticsConfiguration_Call{Call: _e.mock.On("PutBucketAnalyticsConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketAnalyticsConfiguration_Call) Run(run func(_a0 *s3.PutBucketAnalyticsConfigurationInput)) *S3API_PutBucketAnalyticsConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketAnalyticsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAnalyticsConfiguration_Call) Return(_a0 *s3.PutBucketAnalyticsConfigurationOutput, _a1 error) *S3API_PutBucketAnalyticsConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAnalyticsConfiguration_Call) RunAndReturn(run func(*s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error)) *S3API_PutBucketAnalyticsConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAnalyticsConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketAnalyticsConfigurationRequest(_a0 *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAnalyticsConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketAnalyticsConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketAnalyticsConfigurationInput) *s3.PutBucketAnalyticsConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAnalyticsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAnalyticsConfigurationRequest'
-type S3API_PutBucketAnalyticsConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketAnalyticsConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketAnalyticsConfigurationInput
-func (_e *S3API_Expecter) PutBucketAnalyticsConfigurationRequest(_a0 interface{}) *S3API_PutBucketAnalyticsConfigurationRequest_Call {
-	return &S3API_PutBucketAnalyticsConfigurationRequest_Call{Call: _e.mock.On("PutBucketAnalyticsConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketAnalyticsConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketAnalyticsConfigurationInput)) *S3API_PutBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketAnalyticsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAnalyticsConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketAnalyticsConfigurationOutput) *S3API_PutBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAnalyticsConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput)) *S3API_PutBucketAnalyticsConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketAnalyticsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketAnalyticsConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketAnalyticsConfigurationInput, _a2 ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketAnalyticsConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketAnalyticsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) *s3.PutBucketAnalyticsConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketAnalyticsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketAnalyticsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAnalyticsConfigurationWithContext'
-type S3API_PutBucketAnalyticsConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketAnalyticsConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketAnalyticsConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketAnalyticsConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketAnalyticsConfigurationWithContext_Call {
-	return &S3API_PutBucketAnalyticsConfigurationWithContext_Call{Call: _e.mock.On("PutBucketAnalyticsConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketAnalyticsConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketAnalyticsConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketAnalyticsConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketAnalyticsConfigurationWithContext_Call) Return(_a0 *s3.PutBucketAnalyticsConfigurationOutput, _a1 error) *S3API_PutBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketAnalyticsConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error)) *S3API_PutBucketAnalyticsConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketCors provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketCors(_a0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketCors")
-	}
-
-	var r0 *s3.PutBucketCorsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) *s3.PutBucketCorsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketCorsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketCorsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketCors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketCors'
-type S3API_PutBucketCors_Call struct {
-	*mock.Call
-}
-
-// PutBucketCors is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketCorsInput
-func (_e *S3API_Expecter) PutBucketCors(_a0 interface{}) *S3API_PutBucketCors_Call {
-	return &S3API_PutBucketCors_Call{Call: _e.mock.On("PutBucketCors", _a0)}
-}
-
-func (_c *S3API_PutBucketCors_Call) Run(run func(_a0 *s3.PutBucketCorsInput)) *S3API_PutBucketCors_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketCorsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketCors_Call) Return(_a0 *s3.PutBucketCorsOutput, _a1 error) *S3API_PutBucketCors_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketCors_Call) RunAndReturn(run func(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)) *S3API_PutBucketCors_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketCorsRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketCorsRequest(_a0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketCorsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketCorsOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketCorsInput) *s3.PutBucketCorsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketCorsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketCorsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketCorsRequest'
-type S3API_PutBucketCorsRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketCorsRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketCorsInput
-func (_e *S3API_Expecter) PutBucketCorsRequest(_a0 interface{}) *S3API_PutBucketCorsRequest_Call {
-	return &S3API_PutBucketCorsRequest_Call{Call: _e.mock.On("PutBucketCorsRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketCorsRequest_Call) Run(run func(_a0 *s3.PutBucketCorsInput)) *S3API_PutBucketCorsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketCorsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketCorsRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketCorsOutput) *S3API_PutBucketCorsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketCorsRequest_Call) RunAndReturn(run func(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)) *S3API_PutBucketCorsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketCorsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketCorsWithContext(_a0 aws.Context, _a1 *s3.PutBucketCorsInput, _a2 ...request.Option) (*s3.PutBucketCorsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketCorsWithContext")
-	}
-
-	var r0 *s3.PutBucketCorsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) *s3.PutBucketCorsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketCorsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketCorsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketCorsWithContext'
-type S3API_PutBucketCorsWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketCorsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketCorsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketCorsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketCorsWithContext_Call {
-	return &S3API_PutBucketCorsWithContext_Call{Call: _e.mock.On("PutBucketCorsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketCorsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketCorsInput, _a2 ...request.Option)) *S3API_PutBucketCorsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketCorsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketCorsWithContext_Call) Return(_a0 *s3.PutBucketCorsOutput, _a1 error) *S3API_PutBucketCorsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketCorsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error)) *S3API_PutBucketCorsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketEncryption provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketEncryption(_a0 *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketEncryption")
-	}
-
-	var r0 *s3.PutBucketEncryptionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) *s3.PutBucketEncryptionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketEncryptionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketEncryptionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketEncryption'
-type S3API_PutBucketEncryption_Call struct {
-	*mock.Call
-}
-
-// PutBucketEncryption is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketEncryptionInput
-func (_e *S3API_Expecter) PutBucketEncryption(_a0 interface{}) *S3API_PutBucketEncryption_Call {
-	return &S3API_PutBucketEncryption_Call{Call: _e.mock.On("PutBucketEncryption", _a0)}
-}
-
-func (_c *S3API_PutBucketEncryption_Call) Run(run func(_a0 *s3.PutBucketEncryptionInput)) *S3API_PutBucketEncryption_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketEncryptionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketEncryption_Call) Return(_a0 *s3.PutBucketEncryptionOutput, _a1 error) *S3API_PutBucketEncryption_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketEncryption_Call) RunAndReturn(run func(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)) *S3API_PutBucketEncryption_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketEncryptionRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketEncryptionRequest(_a0 *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketEncryptionRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketEncryptionOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketEncryptionInput) *s3.PutBucketEncryptionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketEncryptionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketEncryptionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketEncryptionRequest'
-type S3API_PutBucketEncryptionRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketEncryptionRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketEncryptionInput
-func (_e *S3API_Expecter) PutBucketEncryptionRequest(_a0 interface{}) *S3API_PutBucketEncryptionRequest_Call {
-	return &S3API_PutBucketEncryptionRequest_Call{Call: _e.mock.On("PutBucketEncryptionRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketEncryptionRequest_Call) Run(run func(_a0 *s3.PutBucketEncryptionInput)) *S3API_PutBucketEncryptionRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketEncryptionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketEncryptionRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketEncryptionOutput) *S3API_PutBucketEncryptionRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketEncryptionRequest_Call) RunAndReturn(run func(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)) *S3API_PutBucketEncryptionRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketEncryptionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketEncryptionWithContext(_a0 aws.Context, _a1 *s3.PutBucketEncryptionInput, _a2 ...request.Option) (*s3.PutBucketEncryptionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketEncryptionWithContext")
-	}
-
-	var r0 *s3.PutBucketEncryptionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) *s3.PutBucketEncryptionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketEncryptionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketEncryptionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketEncryptionWithContext'
-type S3API_PutBucketEncryptionWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketEncryptionWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketEncryptionInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketEncryptionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketEncryptionWithContext_Call {
-	return &S3API_PutBucketEncryptionWithContext_Call{Call: _e.mock.On("PutBucketEncryptionWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketEncryptionWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketEncryptionInput, _a2 ...request.Option)) *S3API_PutBucketEncryptionWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketEncryptionInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketEncryptionWithContext_Call) Return(_a0 *s3.PutBucketEncryptionOutput, _a1 error) *S3API_PutBucketEncryptionWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketEncryptionWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error)) *S3API_PutBucketEncryptionWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketIntelligentTieringConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketIntelligentTieringConfiguration(_a0 *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketIntelligentTieringConfiguration")
-	}
-
-	var r0 *s3.PutBucketIntelligentTieringConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *s3.PutBucketIntelligentTieringConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketIntelligentTieringConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketIntelligentTieringConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketIntelligentTieringConfiguration'
-type S3API_PutBucketIntelligentTieringConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketIntelligentTieringConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketIntelligentTieringConfigurationInput
-func (_e *S3API_Expecter) PutBucketIntelligentTieringConfiguration(_a0 interface{}) *S3API_PutBucketIntelligentTieringConfiguration_Call {
-	return &S3API_PutBucketIntelligentTieringConfiguration_Call{Call: _e.mock.On("PutBucketIntelligentTieringConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfiguration_Call) Run(run func(_a0 *s3.PutBucketIntelligentTieringConfigurationInput)) *S3API_PutBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketIntelligentTieringConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfiguration_Call) Return(_a0 *s3.PutBucketIntelligentTieringConfigurationOutput, _a1 error) *S3API_PutBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfiguration_Call) RunAndReturn(run func(*s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)) *S3API_PutBucketIntelligentTieringConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketIntelligentTieringConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketIntelligentTieringConfigurationRequest(_a0 *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketIntelligentTieringConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketIntelligentTieringConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *s3.PutBucketIntelligentTieringConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketIntelligentTieringConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketIntelligentTieringConfigurationRequest'
-type S3API_PutBucketIntelligentTieringConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketIntelligentTieringConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketIntelligentTieringConfigurationInput
-func (_e *S3API_Expecter) PutBucketIntelligentTieringConfigurationRequest(_a0 interface{}) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call {
-	return &S3API_PutBucketIntelligentTieringConfigurationRequest_Call{Call: _e.mock.On("PutBucketIntelligentTieringConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketIntelligentTieringConfigurationInput)) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketIntelligentTieringConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketIntelligentTieringConfigurationOutput) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput)) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketIntelligentTieringConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketIntelligentTieringConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketIntelligentTieringConfigurationInput, _a2 ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketIntelligentTieringConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketIntelligentTieringConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.PutBucketIntelligentTieringConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketIntelligentTieringConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketIntelligentTieringConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketIntelligentTieringConfigurationWithContext'
-type S3API_PutBucketIntelligentTieringConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketIntelligentTieringConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketIntelligentTieringConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketIntelligentTieringConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call {
-	return &S3API_PutBucketIntelligentTieringConfigurationWithContext_Call{Call: _e.mock.On("PutBucketIntelligentTieringConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketIntelligentTieringConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketIntelligentTieringConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call) Return(_a0 *s3.PutBucketIntelligentTieringConfigurationOutput, _a1 error) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketInventoryConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketInventoryConfiguration(_a0 *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketInventoryConfiguration")
-	}
-
-	var r0 *s3.PutBucketInventoryConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) *s3.PutBucketInventoryConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketInventoryConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketInventoryConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketInventoryConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketInventoryConfiguration'
-type S3API_PutBucketInventoryConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketInventoryConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketInventoryConfigurationInput
-func (_e *S3API_Expecter) PutBucketInventoryConfiguration(_a0 interface{}) *S3API_PutBucketInventoryConfiguration_Call {
-	return &S3API_PutBucketInventoryConfiguration_Call{Call: _e.mock.On("PutBucketInventoryConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketInventoryConfiguration_Call) Run(run func(_a0 *s3.PutBucketInventoryConfigurationInput)) *S3API_PutBucketInventoryConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketInventoryConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketInventoryConfiguration_Call) Return(_a0 *s3.PutBucketInventoryConfigurationOutput, _a1 error) *S3API_PutBucketInventoryConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketInventoryConfiguration_Call) RunAndReturn(run func(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)) *S3API_PutBucketInventoryConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketInventoryConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketInventoryConfigurationRequest(_a0 *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketInventoryConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketInventoryConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketInventoryConfigurationInput) *s3.PutBucketInventoryConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketInventoryConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketInventoryConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketInventoryConfigurationRequest'
-type S3API_PutBucketInventoryConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketInventoryConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketInventoryConfigurationInput
-func (_e *S3API_Expecter) PutBucketInventoryConfigurationRequest(_a0 interface{}) *S3API_PutBucketInventoryConfigurationRequest_Call {
-	return &S3API_PutBucketInventoryConfigurationRequest_Call{Call: _e.mock.On("PutBucketInventoryConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketInventoryConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketInventoryConfigurationInput)) *S3API_PutBucketInventoryConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketInventoryConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketInventoryConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketInventoryConfigurationOutput) *S3API_PutBucketInventoryConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketInventoryConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)) *S3API_PutBucketInventoryConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketInventoryConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketInventoryConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketInventoryConfigurationInput, _a2 ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketInventoryConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketInventoryConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) *s3.PutBucketInventoryConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketInventoryConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketInventoryConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketInventoryConfigurationWithContext'
-type S3API_PutBucketInventoryConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketInventoryConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketInventoryConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketInventoryConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketInventoryConfigurationWithContext_Call {
-	return &S3API_PutBucketInventoryConfigurationWithContext_Call{Call: _e.mock.On("PutBucketInventoryConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketInventoryConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketInventoryConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketInventoryConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketInventoryConfigurationWithContext_Call) Return(_a0 *s3.PutBucketInventoryConfigurationOutput, _a1 error) *S3API_PutBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketInventoryConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)) *S3API_PutBucketInventoryConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLifecycle provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketLifecycle(_a0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLifecycle")
-	}
-
-	var r0 *s3.PutBucketLifecycleOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) *s3.PutBucketLifecycleOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketLifecycleOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycle'
-type S3API_PutBucketLifecycle_Call struct {
-	*mock.Call
-}
-
-// PutBucketLifecycle is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketLifecycleInput
-func (_e *S3API_Expecter) PutBucketLifecycle(_a0 interface{}) *S3API_PutBucketLifecycle_Call {
-	return &S3API_PutBucketLifecycle_Call{Call: _e.mock.On("PutBucketLifecycle", _a0)}
-}
-
-func (_c *S3API_PutBucketLifecycle_Call) Run(run func(_a0 *s3.PutBucketLifecycleInput)) *S3API_PutBucketLifecycle_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketLifecycleInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycle_Call) Return(_a0 *s3.PutBucketLifecycleOutput, _a1 error) *S3API_PutBucketLifecycle_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycle_Call) RunAndReturn(run func(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)) *S3API_PutBucketLifecycle_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLifecycleConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketLifecycleConfiguration(_a0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLifecycleConfiguration")
-	}
-
-	var r0 *s3.PutBucketLifecycleConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) *s3.PutBucketLifecycleConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketLifecycleConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLifecycleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfiguration'
-type S3API_PutBucketLifecycleConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketLifecycleConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketLifecycleConfigurationInput
-func (_e *S3API_Expecter) PutBucketLifecycleConfiguration(_a0 interface{}) *S3API_PutBucketLifecycleConfiguration_Call {
-	return &S3API_PutBucketLifecycleConfiguration_Call{Call: _e.mock.On("PutBucketLifecycleConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketLifecycleConfiguration_Call) Run(run func(_a0 *s3.PutBucketLifecycleConfigurationInput)) *S3API_PutBucketLifecycleConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketLifecycleConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleConfiguration_Call) Return(_a0 *s3.PutBucketLifecycleConfigurationOutput, _a1 error) *S3API_PutBucketLifecycleConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleConfiguration_Call) RunAndReturn(run func(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)) *S3API_PutBucketLifecycleConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLifecycleConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketLifecycleConfigurationRequest(_a0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLifecycleConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketLifecycleConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleConfigurationInput) *s3.PutBucketLifecycleConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketLifecycleConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLifecycleConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfigurationRequest'
-type S3API_PutBucketLifecycleConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketLifecycleConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketLifecycleConfigurationInput
-func (_e *S3API_Expecter) PutBucketLifecycleConfigurationRequest(_a0 interface{}) *S3API_PutBucketLifecycleConfigurationRequest_Call {
-	return &S3API_PutBucketLifecycleConfigurationRequest_Call{Call: _e.mock.On("PutBucketLifecycleConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketLifecycleConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketLifecycleConfigurationInput)) *S3API_PutBucketLifecycleConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketLifecycleConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketLifecycleConfigurationOutput) *S3API_PutBucketLifecycleConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)) *S3API_PutBucketLifecycleConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLifecycleConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketLifecycleConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketLifecycleConfigurationInput, _a2 ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLifecycleConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketLifecycleConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) *s3.PutBucketLifecycleConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketLifecycleConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLifecycleConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfigurationWithContext'
-type S3API_PutBucketLifecycleConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketLifecycleConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketLifecycleConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketLifecycleConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketLifecycleConfigurationWithContext_Call {
-	return &S3API_PutBucketLifecycleConfigurationWithContext_Call{Call: _e.mock.On("PutBucketLifecycleConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketLifecycleConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketLifecycleConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketLifecycleConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketLifecycleConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleConfigurationWithContext_Call) Return(_a0 *s3.PutBucketLifecycleConfigurationOutput, _a1 error) *S3API_PutBucketLifecycleConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error)) *S3API_PutBucketLifecycleConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLifecycleRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketLifecycleRequest(_a0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLifecycleRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketLifecycleOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleInput) *s3.PutBucketLifecycleOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketLifecycleOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLifecycleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleRequest'
-type S3API_PutBucketLifecycleRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketLifecycleRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketLifecycleInput
-func (_e *S3API_Expecter) PutBucketLifecycleRequest(_a0 interface{}) *S3API_PutBucketLifecycleRequest_Call {
-	return &S3API_PutBucketLifecycleRequest_Call{Call: _e.mock.On("PutBucketLifecycleRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketLifecycleRequest_Call) Run(run func(_a0 *s3.PutBucketLifecycleInput)) *S3API_PutBucketLifecycleRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketLifecycleInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketLifecycleOutput) *S3API_PutBucketLifecycleRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleRequest_Call) RunAndReturn(run func(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)) *S3API_PutBucketLifecycleRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLifecycleWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketLifecycleWithContext(_a0 aws.Context, _a1 *s3.PutBucketLifecycleInput, _a2 ...request.Option) (*s3.PutBucketLifecycleOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLifecycleWithContext")
-	}
-
-	var r0 *s3.PutBucketLifecycleOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) (*s3.PutBucketLifecycleOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) *s3.PutBucketLifecycleOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketLifecycleOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLifecycleWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleWithContext'
-type S3API_PutBucketLifecycleWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketLifecycleWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketLifecycleInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketLifecycleWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketLifecycleWithContext_Call {
-	return &S3API_PutBucketLifecycleWithContext_Call{Call: _e.mock.On("PutBucketLifecycleWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketLifecycleWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketLifecycleInput, _a2 ...request.Option)) *S3API_PutBucketLifecycleWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketLifecycleInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleWithContext_Call) Return(_a0 *s3.PutBucketLifecycleOutput, _a1 error) *S3API_PutBucketLifecycleWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLifecycleWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) (*s3.PutBucketLifecycleOutput, error)) *S3API_PutBucketLifecycleWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLogging provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketLogging(_a0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLogging")
-	}
-
-	var r0 *s3.PutBucketLoggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) *s3.PutBucketLoggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketLoggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketLoggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLogging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLogging'
-type S3API_PutBucketLogging_Call struct {
-	*mock.Call
-}
-
-// PutBucketLogging is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketLoggingInput
-func (_e *S3API_Expecter) PutBucketLogging(_a0 interface{}) *S3API_PutBucketLogging_Call {
-	return &S3API_PutBucketLogging_Call{Call: _e.mock.On("PutBucketLogging", _a0)}
-}
-
-func (_c *S3API_PutBucketLogging_Call) Run(run func(_a0 *s3.PutBucketLoggingInput)) *S3API_PutBucketLogging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketLoggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLogging_Call) Return(_a0 *s3.PutBucketLoggingOutput, _a1 error) *S3API_PutBucketLogging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLogging_Call) RunAndReturn(run func(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)) *S3API_PutBucketLogging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLoggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketLoggingRequest(_a0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLoggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketLoggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketLoggingInput) *s3.PutBucketLoggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketLoggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLoggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLoggingRequest'
-type S3API_PutBucketLoggingRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketLoggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketLoggingInput
-func (_e *S3API_Expecter) PutBucketLoggingRequest(_a0 interface{}) *S3API_PutBucketLoggingRequest_Call {
-	return &S3API_PutBucketLoggingRequest_Call{Call: _e.mock.On("PutBucketLoggingRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketLoggingRequest_Call) Run(run func(_a0 *s3.PutBucketLoggingInput)) *S3API_PutBucketLoggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketLoggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLoggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketLoggingOutput) *S3API_PutBucketLoggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLoggingRequest_Call) RunAndReturn(run func(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)) *S3API_PutBucketLoggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketLoggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketLoggingWithContext(_a0 aws.Context, _a1 *s3.PutBucketLoggingInput, _a2 ...request.Option) (*s3.PutBucketLoggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketLoggingWithContext")
-	}
-
-	var r0 *s3.PutBucketLoggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) (*s3.PutBucketLoggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) *s3.PutBucketLoggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketLoggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketLoggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLoggingWithContext'
-type S3API_PutBucketLoggingWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketLoggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketLoggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketLoggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketLoggingWithContext_Call {
-	return &S3API_PutBucketLoggingWithContext_Call{Call: _e.mock.On("PutBucketLoggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketLoggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketLoggingInput, _a2 ...request.Option)) *S3API_PutBucketLoggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketLoggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketLoggingWithContext_Call) Return(_a0 *s3.PutBucketLoggingOutput, _a1 error) *S3API_PutBucketLoggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketLoggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) (*s3.PutBucketLoggingOutput, error)) *S3API_PutBucketLoggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketMetricsConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketMetricsConfiguration(_a0 *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketMetricsConfiguration")
-	}
-
-	var r0 *s3.PutBucketMetricsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) *s3.PutBucketMetricsConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketMetricsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketMetricsConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketMetricsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketMetricsConfiguration'
-type S3API_PutBucketMetricsConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketMetricsConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketMetricsConfigurationInput
-func (_e *S3API_Expecter) PutBucketMetricsConfiguration(_a0 interface{}) *S3API_PutBucketMetricsConfiguration_Call {
-	return &S3API_PutBucketMetricsConfiguration_Call{Call: _e.mock.On("PutBucketMetricsConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketMetricsConfiguration_Call) Run(run func(_a0 *s3.PutBucketMetricsConfigurationInput)) *S3API_PutBucketMetricsConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketMetricsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketMetricsConfiguration_Call) Return(_a0 *s3.PutBucketMetricsConfigurationOutput, _a1 error) *S3API_PutBucketMetricsConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketMetricsConfiguration_Call) RunAndReturn(run func(*s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error)) *S3API_PutBucketMetricsConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketMetricsConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketMetricsConfigurationRequest(_a0 *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketMetricsConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketMetricsConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketMetricsConfigurationInput) *s3.PutBucketMetricsConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketMetricsConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketMetricsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketMetricsConfigurationRequest'
-type S3API_PutBucketMetricsConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketMetricsConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketMetricsConfigurationInput
-func (_e *S3API_Expecter) PutBucketMetricsConfigurationRequest(_a0 interface{}) *S3API_PutBucketMetricsConfigurationRequest_Call {
-	return &S3API_PutBucketMetricsConfigurationRequest_Call{Call: _e.mock.On("PutBucketMetricsConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketMetricsConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketMetricsConfigurationInput)) *S3API_PutBucketMetricsConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketMetricsConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketMetricsConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketMetricsConfigurationOutput) *S3API_PutBucketMetricsConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketMetricsConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput)) *S3API_PutBucketMetricsConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketMetricsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketMetricsConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketMetricsConfigurationInput, _a2 ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketMetricsConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketMetricsConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) *s3.PutBucketMetricsConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketMetricsConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketMetricsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketMetricsConfigurationWithContext'
-type S3API_PutBucketMetricsConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketMetricsConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketMetricsConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketMetricsConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketMetricsConfigurationWithContext_Call {
-	return &S3API_PutBucketMetricsConfigurationWithContext_Call{Call: _e.mock.On("PutBucketMetricsConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketMetricsConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketMetricsConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketMetricsConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketMetricsConfigurationWithContext_Call) Return(_a0 *s3.PutBucketMetricsConfigurationOutput, _a1 error) *S3API_PutBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketMetricsConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error)) *S3API_PutBucketMetricsConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketNotification provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketNotification(_a0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketNotification")
-	}
-
-	var r0 *s3.PutBucketNotificationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) *s3.PutBucketNotificationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketNotificationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotification'
-type S3API_PutBucketNotification_Call struct {
-	*mock.Call
-}
-
-// PutBucketNotification is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketNotificationInput
-func (_e *S3API_Expecter) PutBucketNotification(_a0 interface{}) *S3API_PutBucketNotification_Call {
-	return &S3API_PutBucketNotification_Call{Call: _e.mock.On("PutBucketNotification", _a0)}
-}
-
-func (_c *S3API_PutBucketNotification_Call) Run(run func(_a0 *s3.PutBucketNotificationInput)) *S3API_PutBucketNotification_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketNotificationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketNotification_Call) Return(_a0 *s3.PutBucketNotificationOutput, _a1 error) *S3API_PutBucketNotification_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketNotification_Call) RunAndReturn(run func(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)) *S3API_PutBucketNotification_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketNotificationConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketNotificationConfiguration(_a0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketNotificationConfiguration")
-	}
-
-	var r0 *s3.PutBucketNotificationConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) *s3.PutBucketNotificationConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketNotificationConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketNotificationConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfiguration'
-type S3API_PutBucketNotificationConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutBucketNotificationConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketNotificationConfigurationInput
-func (_e *S3API_Expecter) PutBucketNotificationConfiguration(_a0 interface{}) *S3API_PutBucketNotificationConfiguration_Call {
-	return &S3API_PutBucketNotificationConfiguration_Call{Call: _e.mock.On("PutBucketNotificationConfiguration", _a0)}
-}
-
-func (_c *S3API_PutBucketNotificationConfiguration_Call) Run(run func(_a0 *s3.PutBucketNotificationConfigurationInput)) *S3API_PutBucketNotificationConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketNotificationConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationConfiguration_Call) Return(_a0 *s3.PutBucketNotificationConfigurationOutput, _a1 error) *S3API_PutBucketNotificationConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationConfiguration_Call) RunAndReturn(run func(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)) *S3API_PutBucketNotificationConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketNotificationConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketNotificationConfigurationRequest(_a0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketNotificationConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketNotificationConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationConfigurationInput) *s3.PutBucketNotificationConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketNotificationConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketNotificationConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfigurationRequest'
-type S3API_PutBucketNotificationConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketNotificationConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketNotificationConfigurationInput
-func (_e *S3API_Expecter) PutBucketNotificationConfigurationRequest(_a0 interface{}) *S3API_PutBucketNotificationConfigurationRequest_Call {
-	return &S3API_PutBucketNotificationConfigurationRequest_Call{Call: _e.mock.On("PutBucketNotificationConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketNotificationConfigurationRequest_Call) Run(run func(_a0 *s3.PutBucketNotificationConfigurationInput)) *S3API_PutBucketNotificationConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketNotificationConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketNotificationConfigurationOutput) *S3API_PutBucketNotificationConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationConfigurationRequest_Call) RunAndReturn(run func(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)) *S3API_PutBucketNotificationConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketNotificationConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketNotificationConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutBucketNotificationConfigurationInput, _a2 ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketNotificationConfigurationWithContext")
-	}
-
-	var r0 *s3.PutBucketNotificationConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) *s3.PutBucketNotificationConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketNotificationConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketNotificationConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfigurationWithContext'
-type S3API_PutBucketNotificationConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketNotificationConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketNotificationConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketNotificationConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketNotificationConfigurationWithContext_Call {
-	return &S3API_PutBucketNotificationConfigurationWithContext_Call{Call: _e.mock.On("PutBucketNotificationConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketNotificationConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketNotificationConfigurationInput, _a2 ...request.Option)) *S3API_PutBucketNotificationConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketNotificationConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationConfigurationWithContext_Call) Return(_a0 *s3.PutBucketNotificationConfigurationOutput, _a1 error) *S3API_PutBucketNotificationConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error)) *S3API_PutBucketNotificationConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketNotificationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketNotificationRequest(_a0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketNotificationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketNotificationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationInput) *s3.PutBucketNotificationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketNotificationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketNotificationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationRequest'
-type S3API_PutBucketNotificationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketNotificationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketNotificationInput
-func (_e *S3API_Expecter) PutBucketNotificationRequest(_a0 interface{}) *S3API_PutBucketNotificationRequest_Call {
-	return &S3API_PutBucketNotificationRequest_Call{Call: _e.mock.On("PutBucketNotificationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketNotificationRequest_Call) Run(run func(_a0 *s3.PutBucketNotificationInput)) *S3API_PutBucketNotificationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketNotificationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketNotificationOutput) *S3API_PutBucketNotificationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationRequest_Call) RunAndReturn(run func(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)) *S3API_PutBucketNotificationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketNotificationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketNotificationWithContext(_a0 aws.Context, _a1 *s3.PutBucketNotificationInput, _a2 ...request.Option) (*s3.PutBucketNotificationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketNotificationWithContext")
-	}
-
-	var r0 *s3.PutBucketNotificationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) (*s3.PutBucketNotificationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) *s3.PutBucketNotificationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketNotificationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketNotificationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationWithContext'
-type S3API_PutBucketNotificationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketNotificationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketNotificationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketNotificationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketNotificationWithContext_Call {
-	return &S3API_PutBucketNotificationWithContext_Call{Call: _e.mock.On("PutBucketNotificationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketNotificationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketNotificationInput, _a2 ...request.Option)) *S3API_PutBucketNotificationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketNotificationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationWithContext_Call) Return(_a0 *s3.PutBucketNotificationOutput, _a1 error) *S3API_PutBucketNotificationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketNotificationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) (*s3.PutBucketNotificationOutput, error)) *S3API_PutBucketNotificationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketOwnershipControls provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketOwnershipControls(_a0 *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketOwnershipControls")
-	}
-
-	var r0 *s3.PutBucketOwnershipControlsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) *s3.PutBucketOwnershipControlsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketOwnershipControlsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketOwnershipControlsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketOwnershipControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketOwnershipControls'
-type S3API_PutBucketOwnershipControls_Call struct {
-	*mock.Call
-}
-
-// PutBucketOwnershipControls is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketOwnershipControlsInput
-func (_e *S3API_Expecter) PutBucketOwnershipControls(_a0 interface{}) *S3API_PutBucketOwnershipControls_Call {
-	return &S3API_PutBucketOwnershipControls_Call{Call: _e.mock.On("PutBucketOwnershipControls", _a0)}
-}
-
-func (_c *S3API_PutBucketOwnershipControls_Call) Run(run func(_a0 *s3.PutBucketOwnershipControlsInput)) *S3API_PutBucketOwnershipControls_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketOwnershipControlsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketOwnershipControls_Call) Return(_a0 *s3.PutBucketOwnershipControlsOutput, _a1 error) *S3API_PutBucketOwnershipControls_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketOwnershipControls_Call) RunAndReturn(run func(*s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error)) *S3API_PutBucketOwnershipControls_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketOwnershipControlsRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketOwnershipControlsRequest(_a0 *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketOwnershipControlsRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketOwnershipControlsOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketOwnershipControlsInput) *s3.PutBucketOwnershipControlsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketOwnershipControlsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketOwnershipControlsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketOwnershipControlsRequest'
-type S3API_PutBucketOwnershipControlsRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketOwnershipControlsRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketOwnershipControlsInput
-func (_e *S3API_Expecter) PutBucketOwnershipControlsRequest(_a0 interface{}) *S3API_PutBucketOwnershipControlsRequest_Call {
-	return &S3API_PutBucketOwnershipControlsRequest_Call{Call: _e.mock.On("PutBucketOwnershipControlsRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketOwnershipControlsRequest_Call) Run(run func(_a0 *s3.PutBucketOwnershipControlsInput)) *S3API_PutBucketOwnershipControlsRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketOwnershipControlsInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketOwnershipControlsRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketOwnershipControlsOutput) *S3API_PutBucketOwnershipControlsRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketOwnershipControlsRequest_Call) RunAndReturn(run func(*s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput)) *S3API_PutBucketOwnershipControlsRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketOwnershipControlsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketOwnershipControlsWithContext(_a0 aws.Context, _a1 *s3.PutBucketOwnershipControlsInput, _a2 ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketOwnershipControlsWithContext")
-	}
-
-	var r0 *s3.PutBucketOwnershipControlsOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) *s3.PutBucketOwnershipControlsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketOwnershipControlsOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketOwnershipControlsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketOwnershipControlsWithContext'
-type S3API_PutBucketOwnershipControlsWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketOwnershipControlsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketOwnershipControlsInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketOwnershipControlsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketOwnershipControlsWithContext_Call {
-	return &S3API_PutBucketOwnershipControlsWithContext_Call{Call: _e.mock.On("PutBucketOwnershipControlsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketOwnershipControlsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketOwnershipControlsInput, _a2 ...request.Option)) *S3API_PutBucketOwnershipControlsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketOwnershipControlsInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketOwnershipControlsWithContext_Call) Return(_a0 *s3.PutBucketOwnershipControlsOutput, _a1 error) *S3API_PutBucketOwnershipControlsWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketOwnershipControlsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error)) *S3API_PutBucketOwnershipControlsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketPolicy provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketPolicy(_a0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketPolicy")
-	}
-
-	var r0 *s3.PutBucketPolicyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) *s3.PutBucketPolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketPolicyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketPolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketPolicy'
-type S3API_PutBucketPolicy_Call struct {
-	*mock.Call
-}
-
-// PutBucketPolicy is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketPolicyInput
-func (_e *S3API_Expecter) PutBucketPolicy(_a0 interface{}) *S3API_PutBucketPolicy_Call {
-	return &S3API_PutBucketPolicy_Call{Call: _e.mock.On("PutBucketPolicy", _a0)}
-}
-
-func (_c *S3API_PutBucketPolicy_Call) Run(run func(_a0 *s3.PutBucketPolicyInput)) *S3API_PutBucketPolicy_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketPolicyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketPolicy_Call) Return(_a0 *s3.PutBucketPolicyOutput, _a1 error) *S3API_PutBucketPolicy_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketPolicy_Call) RunAndReturn(run func(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)) *S3API_PutBucketPolicy_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketPolicyRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketPolicyRequest(_a0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketPolicyRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketPolicyOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketPolicyInput) *s3.PutBucketPolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketPolicyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketPolicyRequest'
-type S3API_PutBucketPolicyRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketPolicyRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketPolicyInput
-func (_e *S3API_Expecter) PutBucketPolicyRequest(_a0 interface{}) *S3API_PutBucketPolicyRequest_Call {
-	return &S3API_PutBucketPolicyRequest_Call{Call: _e.mock.On("PutBucketPolicyRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketPolicyRequest_Call) Run(run func(_a0 *s3.PutBucketPolicyInput)) *S3API_PutBucketPolicyRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketPolicyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketPolicyRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketPolicyOutput) *S3API_PutBucketPolicyRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketPolicyRequest_Call) RunAndReturn(run func(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)) *S3API_PutBucketPolicyRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketPolicyWithContext(_a0 aws.Context, _a1 *s3.PutBucketPolicyInput, _a2 ...request.Option) (*s3.PutBucketPolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketPolicyWithContext")
-	}
-
-	var r0 *s3.PutBucketPolicyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) (*s3.PutBucketPolicyOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) *s3.PutBucketPolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketPolicyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketPolicyWithContext'
-type S3API_PutBucketPolicyWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketPolicyWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketPolicyInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketPolicyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketPolicyWithContext_Call {
-	return &S3API_PutBucketPolicyWithContext_Call{Call: _e.mock.On("PutBucketPolicyWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketPolicyWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketPolicyInput, _a2 ...request.Option)) *S3API_PutBucketPolicyWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketPolicyInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketPolicyWithContext_Call) Return(_a0 *s3.PutBucketPolicyOutput, _a1 error) *S3API_PutBucketPolicyWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketPolicyWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) (*s3.PutBucketPolicyOutput, error)) *S3API_PutBucketPolicyWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketReplication provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketReplication(_a0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketReplication")
-	}
-
-	var r0 *s3.PutBucketReplicationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) *s3.PutBucketReplicationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketReplicationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketReplicationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketReplication'
-type S3API_PutBucketReplication_Call struct {
-	*mock.Call
-}
-
-// PutBucketReplication is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketReplicationInput
-func (_e *S3API_Expecter) PutBucketReplication(_a0 interface{}) *S3API_PutBucketReplication_Call {
-	return &S3API_PutBucketReplication_Call{Call: _e.mock.On("PutBucketReplication", _a0)}
-}
-
-func (_c *S3API_PutBucketReplication_Call) Run(run func(_a0 *s3.PutBucketReplicationInput)) *S3API_PutBucketReplication_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketReplicationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketReplication_Call) Return(_a0 *s3.PutBucketReplicationOutput, _a1 error) *S3API_PutBucketReplication_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketReplication_Call) RunAndReturn(run func(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)) *S3API_PutBucketReplication_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketReplicationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketReplicationRequest(_a0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketReplicationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketReplicationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketReplicationInput) *s3.PutBucketReplicationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketReplicationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketReplicationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketReplicationRequest'
-type S3API_PutBucketReplicationRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketReplicationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketReplicationInput
-func (_e *S3API_Expecter) PutBucketReplicationRequest(_a0 interface{}) *S3API_PutBucketReplicationRequest_Call {
-	return &S3API_PutBucketReplicationRequest_Call{Call: _e.mock.On("PutBucketReplicationRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketReplicationRequest_Call) Run(run func(_a0 *s3.PutBucketReplicationInput)) *S3API_PutBucketReplicationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketReplicationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketReplicationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketReplicationOutput) *S3API_PutBucketReplicationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketReplicationRequest_Call) RunAndReturn(run func(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)) *S3API_PutBucketReplicationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketReplicationWithContext(_a0 aws.Context, _a1 *s3.PutBucketReplicationInput, _a2 ...request.Option) (*s3.PutBucketReplicationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketReplicationWithContext")
-	}
-
-	var r0 *s3.PutBucketReplicationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) (*s3.PutBucketReplicationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) *s3.PutBucketReplicationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketReplicationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketReplicationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketReplicationWithContext'
-type S3API_PutBucketReplicationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketReplicationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketReplicationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketReplicationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketReplicationWithContext_Call {
-	return &S3API_PutBucketReplicationWithContext_Call{Call: _e.mock.On("PutBucketReplicationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketReplicationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketReplicationInput, _a2 ...request.Option)) *S3API_PutBucketReplicationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketReplicationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketReplicationWithContext_Call) Return(_a0 *s3.PutBucketReplicationOutput, _a1 error) *S3API_PutBucketReplicationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketReplicationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) (*s3.PutBucketReplicationOutput, error)) *S3API_PutBucketReplicationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketRequestPayment provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketRequestPayment(_a0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketRequestPayment")
-	}
-
-	var r0 *s3.PutBucketRequestPaymentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) *s3.PutBucketRequestPaymentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketRequestPaymentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketRequestPaymentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketRequestPayment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketRequestPayment'
-type S3API_PutBucketRequestPayment_Call struct {
-	*mock.Call
-}
-
-// PutBucketRequestPayment is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketRequestPaymentInput
-func (_e *S3API_Expecter) PutBucketRequestPayment(_a0 interface{}) *S3API_PutBucketRequestPayment_Call {
-	return &S3API_PutBucketRequestPayment_Call{Call: _e.mock.On("PutBucketRequestPayment", _a0)}
-}
-
-func (_c *S3API_PutBucketRequestPayment_Call) Run(run func(_a0 *s3.PutBucketRequestPaymentInput)) *S3API_PutBucketRequestPayment_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketRequestPaymentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketRequestPayment_Call) Return(_a0 *s3.PutBucketRequestPaymentOutput, _a1 error) *S3API_PutBucketRequestPayment_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketRequestPayment_Call) RunAndReturn(run func(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)) *S3API_PutBucketRequestPayment_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketRequestPaymentRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketRequestPaymentRequest(_a0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketRequestPaymentRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketRequestPaymentOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketRequestPaymentInput) *s3.PutBucketRequestPaymentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketRequestPaymentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketRequestPaymentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketRequestPaymentRequest'
-type S3API_PutBucketRequestPaymentRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketRequestPaymentRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketRequestPaymentInput
-func (_e *S3API_Expecter) PutBucketRequestPaymentRequest(_a0 interface{}) *S3API_PutBucketRequestPaymentRequest_Call {
-	return &S3API_PutBucketRequestPaymentRequest_Call{Call: _e.mock.On("PutBucketRequestPaymentRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketRequestPaymentRequest_Call) Run(run func(_a0 *s3.PutBucketRequestPaymentInput)) *S3API_PutBucketRequestPaymentRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketRequestPaymentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketRequestPaymentRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketRequestPaymentOutput) *S3API_PutBucketRequestPaymentRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketRequestPaymentRequest_Call) RunAndReturn(run func(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)) *S3API_PutBucketRequestPaymentRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketRequestPaymentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketRequestPaymentWithContext(_a0 aws.Context, _a1 *s3.PutBucketRequestPaymentInput, _a2 ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketRequestPaymentWithContext")
-	}
-
-	var r0 *s3.PutBucketRequestPaymentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) (*s3.PutBucketRequestPaymentOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) *s3.PutBucketRequestPaymentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketRequestPaymentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketRequestPaymentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketRequestPaymentWithContext'
-type S3API_PutBucketRequestPaymentWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketRequestPaymentWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketRequestPaymentInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketRequestPaymentWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketRequestPaymentWithContext_Call {
-	return &S3API_PutBucketRequestPaymentWithContext_Call{Call: _e.mock.On("PutBucketRequestPaymentWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketRequestPaymentWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketRequestPaymentInput, _a2 ...request.Option)) *S3API_PutBucketRequestPaymentWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketRequestPaymentInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketRequestPaymentWithContext_Call) Return(_a0 *s3.PutBucketRequestPaymentOutput, _a1 error) *S3API_PutBucketRequestPaymentWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketRequestPaymentWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) (*s3.PutBucketRequestPaymentOutput, error)) *S3API_PutBucketRequestPaymentWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketTagging provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketTagging(_a0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketTagging")
-	}
-
-	var r0 *s3.PutBucketTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) *s3.PutBucketTaggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketTaggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketTagging'
-type S3API_PutBucketTagging_Call struct {
-	*mock.Call
-}
-
-// PutBucketTagging is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketTaggingInput
-func (_e *S3API_Expecter) PutBucketTagging(_a0 interface{}) *S3API_PutBucketTagging_Call {
-	return &S3API_PutBucketTagging_Call{Call: _e.mock.On("PutBucketTagging", _a0)}
-}
-
-func (_c *S3API_PutBucketTagging_Call) Run(run func(_a0 *s3.PutBucketTaggingInput)) *S3API_PutBucketTagging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketTagging_Call) Return(_a0 *s3.PutBucketTaggingOutput, _a1 error) *S3API_PutBucketTagging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketTagging_Call) RunAndReturn(run func(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)) *S3API_PutBucketTagging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketTaggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketTaggingRequest(_a0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketTaggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketTaggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketTaggingInput) *s3.PutBucketTaggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketTaggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketTaggingRequest'
-type S3API_PutBucketTaggingRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketTaggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketTaggingInput
-func (_e *S3API_Expecter) PutBucketTaggingRequest(_a0 interface{}) *S3API_PutBucketTaggingRequest_Call {
-	return &S3API_PutBucketTaggingRequest_Call{Call: _e.mock.On("PutBucketTaggingRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketTaggingRequest_Call) Run(run func(_a0 *s3.PutBucketTaggingInput)) *S3API_PutBucketTaggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketTaggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketTaggingOutput) *S3API_PutBucketTaggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketTaggingRequest_Call) RunAndReturn(run func(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)) *S3API_PutBucketTaggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketTaggingWithContext(_a0 aws.Context, _a1 *s3.PutBucketTaggingInput, _a2 ...request.Option) (*s3.PutBucketTaggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketTaggingWithContext")
-	}
-
-	var r0 *s3.PutBucketTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) (*s3.PutBucketTaggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) *s3.PutBucketTaggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketTaggingWithContext'
-type S3API_PutBucketTaggingWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketTaggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketTaggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketTaggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketTaggingWithContext_Call {
-	return &S3API_PutBucketTaggingWithContext_Call{Call: _e.mock.On("PutBucketTaggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketTaggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketTaggingInput, _a2 ...request.Option)) *S3API_PutBucketTaggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketTaggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketTaggingWithContext_Call) Return(_a0 *s3.PutBucketTaggingOutput, _a1 error) *S3API_PutBucketTaggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketTaggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) (*s3.PutBucketTaggingOutput, error)) *S3API_PutBucketTaggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketVersioning provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketVersioning(_a0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketVersioning")
-	}
-
-	var r0 *s3.PutBucketVersioningOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) *s3.PutBucketVersioningOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketVersioningOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketVersioningInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketVersioning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketVersioning'
-type S3API_PutBucketVersioning_Call struct {
-	*mock.Call
-}
-
-// PutBucketVersioning is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketVersioningInput
-func (_e *S3API_Expecter) PutBucketVersioning(_a0 interface{}) *S3API_PutBucketVersioning_Call {
-	return &S3API_PutBucketVersioning_Call{Call: _e.mock.On("PutBucketVersioning", _a0)}
-}
-
-func (_c *S3API_PutBucketVersioning_Call) Run(run func(_a0 *s3.PutBucketVersioningInput)) *S3API_PutBucketVersioning_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketVersioningInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketVersioning_Call) Return(_a0 *s3.PutBucketVersioningOutput, _a1 error) *S3API_PutBucketVersioning_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketVersioning_Call) RunAndReturn(run func(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)) *S3API_PutBucketVersioning_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketVersioningRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketVersioningRequest(_a0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketVersioningRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketVersioningOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketVersioningInput) *s3.PutBucketVersioningOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketVersioningOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketVersioningRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketVersioningRequest'
-type S3API_PutBucketVersioningRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketVersioningRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketVersioningInput
-func (_e *S3API_Expecter) PutBucketVersioningRequest(_a0 interface{}) *S3API_PutBucketVersioningRequest_Call {
-	return &S3API_PutBucketVersioningRequest_Call{Call: _e.mock.On("PutBucketVersioningRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketVersioningRequest_Call) Run(run func(_a0 *s3.PutBucketVersioningInput)) *S3API_PutBucketVersioningRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketVersioningInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketVersioningRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketVersioningOutput) *S3API_PutBucketVersioningRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketVersioningRequest_Call) RunAndReturn(run func(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)) *S3API_PutBucketVersioningRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketVersioningWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketVersioningWithContext(_a0 aws.Context, _a1 *s3.PutBucketVersioningInput, _a2 ...request.Option) (*s3.PutBucketVersioningOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketVersioningWithContext")
-	}
-
-	var r0 *s3.PutBucketVersioningOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) (*s3.PutBucketVersioningOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) *s3.PutBucketVersioningOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketVersioningOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketVersioningWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketVersioningWithContext'
-type S3API_PutBucketVersioningWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketVersioningWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketVersioningInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketVersioningWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketVersioningWithContext_Call {
-	return &S3API_PutBucketVersioningWithContext_Call{Call: _e.mock.On("PutBucketVersioningWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketVersioningWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketVersioningInput, _a2 ...request.Option)) *S3API_PutBucketVersioningWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketVersioningInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketVersioningWithContext_Call) Return(_a0 *s3.PutBucketVersioningOutput, _a1 error) *S3API_PutBucketVersioningWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketVersioningWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) (*s3.PutBucketVersioningOutput, error)) *S3API_PutBucketVersioningWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketWebsite provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketWebsite(_a0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketWebsite")
-	}
-
-	var r0 *s3.PutBucketWebsiteOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) *s3.PutBucketWebsiteOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketWebsiteOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketWebsiteInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketWebsite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketWebsite'
-type S3API_PutBucketWebsite_Call struct {
-	*mock.Call
-}
-
-// PutBucketWebsite is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketWebsiteInput
-func (_e *S3API_Expecter) PutBucketWebsite(_a0 interface{}) *S3API_PutBucketWebsite_Call {
-	return &S3API_PutBucketWebsite_Call{Call: _e.mock.On("PutBucketWebsite", _a0)}
-}
-
-func (_c *S3API_PutBucketWebsite_Call) Run(run func(_a0 *s3.PutBucketWebsiteInput)) *S3API_PutBucketWebsite_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketWebsiteInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketWebsite_Call) Return(_a0 *s3.PutBucketWebsiteOutput, _a1 error) *S3API_PutBucketWebsite_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketWebsite_Call) RunAndReturn(run func(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)) *S3API_PutBucketWebsite_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketWebsiteRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutBucketWebsiteRequest(_a0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketWebsiteRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutBucketWebsiteOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutBucketWebsiteInput) *s3.PutBucketWebsiteOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutBucketWebsiteOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketWebsiteRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketWebsiteRequest'
-type S3API_PutBucketWebsiteRequest_Call struct {
-	*mock.Call
-}
-
-// PutBucketWebsiteRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutBucketWebsiteInput
-func (_e *S3API_Expecter) PutBucketWebsiteRequest(_a0 interface{}) *S3API_PutBucketWebsiteRequest_Call {
-	return &S3API_PutBucketWebsiteRequest_Call{Call: _e.mock.On("PutBucketWebsiteRequest", _a0)}
-}
-
-func (_c *S3API_PutBucketWebsiteRequest_Call) Run(run func(_a0 *s3.PutBucketWebsiteInput)) *S3API_PutBucketWebsiteRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutBucketWebsiteInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketWebsiteRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutBucketWebsiteOutput) *S3API_PutBucketWebsiteRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketWebsiteRequest_Call) RunAndReturn(run func(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)) *S3API_PutBucketWebsiteRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutBucketWebsiteWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutBucketWebsiteWithContext(_a0 aws.Context, _a1 *s3.PutBucketWebsiteInput, _a2 ...request.Option) (*s3.PutBucketWebsiteOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutBucketWebsiteWithContext")
-	}
-
-	var r0 *s3.PutBucketWebsiteOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) (*s3.PutBucketWebsiteOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) *s3.PutBucketWebsiteOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutBucketWebsiteOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutBucketWebsiteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketWebsiteWithContext'
-type S3API_PutBucketWebsiteWithContext_Call struct {
-	*mock.Call
-}
-
-// PutBucketWebsiteWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutBucketWebsiteInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutBucketWebsiteWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutBucketWebsiteWithContext_Call {
-	return &S3API_PutBucketWebsiteWithContext_Call{Call: _e.mock.On("PutBucketWebsiteWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutBucketWebsiteWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutBucketWebsiteInput, _a2 ...request.Option)) *S3API_PutBucketWebsiteWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutBucketWebsiteInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutBucketWebsiteWithContext_Call) Return(_a0 *s3.PutBucketWebsiteOutput, _a1 error) *S3API_PutBucketWebsiteWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutBucketWebsiteWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) (*s3.PutBucketWebsiteOutput, error)) *S3API_PutBucketWebsiteWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObject provides a mock function with given fields: _a0
-func (_m *S3API) PutObject(_a0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObject")
-	}
-
-	var r0 *s3.PutObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) (*s3.PutObjectOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) *s3.PutObjectOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObject'
-type S3API_PutObject_Call struct {
-	*mock.Call
-}
-
-// PutObject is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectInput
-func (_e *S3API_Expecter) PutObject(_a0 interface{}) *S3API_PutObject_Call {
-	return &S3API_PutObject_Call{Call: _e.mock.On("PutObject", _a0)}
-}
-
-func (_c *S3API_PutObject_Call) Run(run func(_a0 *s3.PutObjectInput)) *S3API_PutObject_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObject_Call) Return(_a0 *s3.PutObjectOutput, _a1 error) *S3API_PutObject_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObject_Call) RunAndReturn(run func(*s3.PutObjectInput) (*s3.PutObjectOutput, error)) *S3API_PutObject_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectAcl provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectAcl(_a0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectAcl")
-	}
-
-	var r0 *s3.PutObjectAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) *s3.PutObjectAclOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectAclInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAcl'
-type S3API_PutObjectAcl_Call struct {
-	*mock.Call
-}
-
-// PutObjectAcl is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectAclInput
-func (_e *S3API_Expecter) PutObjectAcl(_a0 interface{}) *S3API_PutObjectAcl_Call {
-	return &S3API_PutObjectAcl_Call{Call: _e.mock.On("PutObjectAcl", _a0)}
-}
-
-func (_c *S3API_PutObjectAcl_Call) Run(run func(_a0 *s3.PutObjectAclInput)) *S3API_PutObjectAcl_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectAcl_Call) Return(_a0 *s3.PutObjectAclOutput, _a1 error) *S3API_PutObjectAcl_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectAcl_Call) RunAndReturn(run func(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)) *S3API_PutObjectAcl_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectAclRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectAclRequest(_a0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectAclRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutObjectAclOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectAclInput) *s3.PutObjectAclOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutObjectAclOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAclRequest'
-type S3API_PutObjectAclRequest_Call struct {
-	*mock.Call
-}
-
-// PutObjectAclRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectAclInput
-func (_e *S3API_Expecter) PutObjectAclRequest(_a0 interface{}) *S3API_PutObjectAclRequest_Call {
-	return &S3API_PutObjectAclRequest_Call{Call: _e.mock.On("PutObjectAclRequest", _a0)}
-}
-
-func (_c *S3API_PutObjectAclRequest_Call) Run(run func(_a0 *s3.PutObjectAclInput)) *S3API_PutObjectAclRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectAclInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectAclRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutObjectAclOutput) *S3API_PutObjectAclRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectAclRequest_Call) RunAndReturn(run func(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)) *S3API_PutObjectAclRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectAclWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutObjectAclWithContext(_a0 aws.Context, _a1 *s3.PutObjectAclInput, _a2 ...request.Option) (*s3.PutObjectAclOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectAclWithContext")
-	}
-
-	var r0 *s3.PutObjectAclOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectAclInput, ...request.Option) (*s3.PutObjectAclOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectAclInput, ...request.Option) *s3.PutObjectAclOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectAclOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectAclInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAclWithContext'
-type S3API_PutObjectAclWithContext_Call struct {
-	*mock.Call
-}
-
-// PutObjectAclWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutObjectAclInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutObjectAclWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutObjectAclWithContext_Call {
-	return &S3API_PutObjectAclWithContext_Call{Call: _e.mock.On("PutObjectAclWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutObjectAclWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutObjectAclInput, _a2 ...request.Option)) *S3API_PutObjectAclWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutObjectAclInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectAclWithContext_Call) Return(_a0 *s3.PutObjectAclOutput, _a1 error) *S3API_PutObjectAclWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectAclWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutObjectAclInput, ...request.Option) (*s3.PutObjectAclOutput, error)) *S3API_PutObjectAclWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectLegalHold provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectLegalHold(_a0 *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectLegalHold")
-	}
-
-	var r0 *s3.PutObjectLegalHoldOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) *s3.PutObjectLegalHoldOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectLegalHoldOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectLegalHoldInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectLegalHold_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLegalHold'
-type S3API_PutObjectLegalHold_Call struct {
-	*mock.Call
-}
-
-// PutObjectLegalHold is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectLegalHoldInput
-func (_e *S3API_Expecter) PutObjectLegalHold(_a0 interface{}) *S3API_PutObjectLegalHold_Call {
-	return &S3API_PutObjectLegalHold_Call{Call: _e.mock.On("PutObjectLegalHold", _a0)}
-}
-
-func (_c *S3API_PutObjectLegalHold_Call) Run(run func(_a0 *s3.PutObjectLegalHoldInput)) *S3API_PutObjectLegalHold_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectLegalHoldInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectLegalHold_Call) Return(_a0 *s3.PutObjectLegalHoldOutput, _a1 error) *S3API_PutObjectLegalHold_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectLegalHold_Call) RunAndReturn(run func(*s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error)) *S3API_PutObjectLegalHold_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectLegalHoldRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectLegalHoldRequest(_a0 *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectLegalHoldRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutObjectLegalHoldOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectLegalHoldInput) *s3.PutObjectLegalHoldOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutObjectLegalHoldOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectLegalHoldRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLegalHoldRequest'
-type S3API_PutObjectLegalHoldRequest_Call struct {
-	*mock.Call
-}
-
-// PutObjectLegalHoldRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectLegalHoldInput
-func (_e *S3API_Expecter) PutObjectLegalHoldRequest(_a0 interface{}) *S3API_PutObjectLegalHoldRequest_Call {
-	return &S3API_PutObjectLegalHoldRequest_Call{Call: _e.mock.On("PutObjectLegalHoldRequest", _a0)}
-}
-
-func (_c *S3API_PutObjectLegalHoldRequest_Call) Run(run func(_a0 *s3.PutObjectLegalHoldInput)) *S3API_PutObjectLegalHoldRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectLegalHoldInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectLegalHoldRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutObjectLegalHoldOutput) *S3API_PutObjectLegalHoldRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectLegalHoldRequest_Call) RunAndReturn(run func(*s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput)) *S3API_PutObjectLegalHoldRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectLegalHoldWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutObjectLegalHoldWithContext(_a0 aws.Context, _a1 *s3.PutObjectLegalHoldInput, _a2 ...request.Option) (*s3.PutObjectLegalHoldOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectLegalHoldWithContext")
-	}
-
-	var r0 *s3.PutObjectLegalHoldOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) (*s3.PutObjectLegalHoldOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) *s3.PutObjectLegalHoldOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectLegalHoldOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectLegalHoldWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLegalHoldWithContext'
-type S3API_PutObjectLegalHoldWithContext_Call struct {
-	*mock.Call
-}
-
-// PutObjectLegalHoldWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutObjectLegalHoldInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutObjectLegalHoldWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutObjectLegalHoldWithContext_Call {
-	return &S3API_PutObjectLegalHoldWithContext_Call{Call: _e.mock.On("PutObjectLegalHoldWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutObjectLegalHoldWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutObjectLegalHoldInput, _a2 ...request.Option)) *S3API_PutObjectLegalHoldWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutObjectLegalHoldInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectLegalHoldWithContext_Call) Return(_a0 *s3.PutObjectLegalHoldOutput, _a1 error) *S3API_PutObjectLegalHoldWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectLegalHoldWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) (*s3.PutObjectLegalHoldOutput, error)) *S3API_PutObjectLegalHoldWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectLockConfiguration provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectLockConfiguration(_a0 *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectLockConfiguration")
-	}
-
-	var r0 *s3.PutObjectLockConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) *s3.PutObjectLockConfigurationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectLockConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectLockConfigurationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectLockConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLockConfiguration'
-type S3API_PutObjectLockConfiguration_Call struct {
-	*mock.Call
-}
-
-// PutObjectLockConfiguration is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectLockConfigurationInput
-func (_e *S3API_Expecter) PutObjectLockConfiguration(_a0 interface{}) *S3API_PutObjectLockConfiguration_Call {
-	return &S3API_PutObjectLockConfiguration_Call{Call: _e.mock.On("PutObjectLockConfiguration", _a0)}
-}
-
-func (_c *S3API_PutObjectLockConfiguration_Call) Run(run func(_a0 *s3.PutObjectLockConfigurationInput)) *S3API_PutObjectLockConfiguration_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectLockConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectLockConfiguration_Call) Return(_a0 *s3.PutObjectLockConfigurationOutput, _a1 error) *S3API_PutObjectLockConfiguration_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectLockConfiguration_Call) RunAndReturn(run func(*s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error)) *S3API_PutObjectLockConfiguration_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectLockConfigurationRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectLockConfigurationRequest(_a0 *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectLockConfigurationRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutObjectLockConfigurationOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectLockConfigurationInput) *s3.PutObjectLockConfigurationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutObjectLockConfigurationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectLockConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLockConfigurationRequest'
-type S3API_PutObjectLockConfigurationRequest_Call struct {
-	*mock.Call
-}
-
-// PutObjectLockConfigurationRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectLockConfigurationInput
-func (_e *S3API_Expecter) PutObjectLockConfigurationRequest(_a0 interface{}) *S3API_PutObjectLockConfigurationRequest_Call {
-	return &S3API_PutObjectLockConfigurationRequest_Call{Call: _e.mock.On("PutObjectLockConfigurationRequest", _a0)}
-}
-
-func (_c *S3API_PutObjectLockConfigurationRequest_Call) Run(run func(_a0 *s3.PutObjectLockConfigurationInput)) *S3API_PutObjectLockConfigurationRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectLockConfigurationInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectLockConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutObjectLockConfigurationOutput) *S3API_PutObjectLockConfigurationRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectLockConfigurationRequest_Call) RunAndReturn(run func(*s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput)) *S3API_PutObjectLockConfigurationRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectLockConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutObjectLockConfigurationWithContext(_a0 aws.Context, _a1 *s3.PutObjectLockConfigurationInput, _a2 ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectLockConfigurationWithContext")
-	}
-
-	var r0 *s3.PutObjectLockConfigurationOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) (*s3.PutObjectLockConfigurationOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) *s3.PutObjectLockConfigurationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectLockConfigurationOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectLockConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLockConfigurationWithContext'
-type S3API_PutObjectLockConfigurationWithContext_Call struct {
-	*mock.Call
-}
-
-// PutObjectLockConfigurationWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutObjectLockConfigurationInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutObjectLockConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutObjectLockConfigurationWithContext_Call {
-	return &S3API_PutObjectLockConfigurationWithContext_Call{Call: _e.mock.On("PutObjectLockConfigurationWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutObjectLockConfigurationWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutObjectLockConfigurationInput, _a2 ...request.Option)) *S3API_PutObjectLockConfigurationWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutObjectLockConfigurationInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectLockConfigurationWithContext_Call) Return(_a0 *s3.PutObjectLockConfigurationOutput, _a1 error) *S3API_PutObjectLockConfigurationWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectLockConfigurationWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) (*s3.PutObjectLockConfigurationOutput, error)) *S3API_PutObjectLockConfigurationWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectRequest(_a0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutObjectOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectInput) *s3.PutObjectOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutObjectOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRequest'
-type S3API_PutObjectRequest_Call struct {
-	*mock.Call
-}
-
-// PutObjectRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectInput
-func (_e *S3API_Expecter) PutObjectRequest(_a0 interface{}) *S3API_PutObjectRequest_Call {
-	return &S3API_PutObjectRequest_Call{Call: _e.mock.On("PutObjectRequest", _a0)}
-}
-
-func (_c *S3API_PutObjectRequest_Call) Run(run func(_a0 *s3.PutObjectInput)) *S3API_PutObjectRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutObjectOutput) *S3API_PutObjectRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectRequest_Call) RunAndReturn(run func(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)) *S3API_PutObjectRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectRetention provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectRetention(_a0 *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectRetention")
-	}
-
-	var r0 *s3.PutObjectRetentionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) *s3.PutObjectRetentionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectRetentionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectRetentionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectRetention_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRetention'
-type S3API_PutObjectRetention_Call struct {
-	*mock.Call
-}
-
-// PutObjectRetention is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectRetentionInput
-func (_e *S3API_Expecter) PutObjectRetention(_a0 interface{}) *S3API_PutObjectRetention_Call {
-	return &S3API_PutObjectRetention_Call{Call: _e.mock.On("PutObjectRetention", _a0)}
-}
-
-func (_c *S3API_PutObjectRetention_Call) Run(run func(_a0 *s3.PutObjectRetentionInput)) *S3API_PutObjectRetention_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectRetentionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectRetention_Call) Return(_a0 *s3.PutObjectRetentionOutput, _a1 error) *S3API_PutObjectRetention_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectRetention_Call) RunAndReturn(run func(*s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error)) *S3API_PutObjectRetention_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectRetentionRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectRetentionRequest(_a0 *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectRetentionRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutObjectRetentionOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectRetentionInput) *s3.PutObjectRetentionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutObjectRetentionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectRetentionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRetentionRequest'
-type S3API_PutObjectRetentionRequest_Call struct {
-	*mock.Call
-}
-
-// PutObjectRetentionRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectRetentionInput
-func (_e *S3API_Expecter) PutObjectRetentionRequest(_a0 interface{}) *S3API_PutObjectRetentionRequest_Call {
-	return &S3API_PutObjectRetentionRequest_Call{Call: _e.mock.On("PutObjectRetentionRequest", _a0)}
-}
-
-func (_c *S3API_PutObjectRetentionRequest_Call) Run(run func(_a0 *s3.PutObjectRetentionInput)) *S3API_PutObjectRetentionRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectRetentionInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectRetentionRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutObjectRetentionOutput) *S3API_PutObjectRetentionRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectRetentionRequest_Call) RunAndReturn(run func(*s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput)) *S3API_PutObjectRetentionRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectRetentionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutObjectRetentionWithContext(_a0 aws.Context, _a1 *s3.PutObjectRetentionInput, _a2 ...request.Option) (*s3.PutObjectRetentionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectRetentionWithContext")
-	}
-
-	var r0 *s3.PutObjectRetentionOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) (*s3.PutObjectRetentionOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) *s3.PutObjectRetentionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectRetentionOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectRetentionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRetentionWithContext'
-type S3API_PutObjectRetentionWithContext_Call struct {
-	*mock.Call
-}
-
-// PutObjectRetentionWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutObjectRetentionInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutObjectRetentionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutObjectRetentionWithContext_Call {
-	return &S3API_PutObjectRetentionWithContext_Call{Call: _e.mock.On("PutObjectRetentionWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutObjectRetentionWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutObjectRetentionInput, _a2 ...request.Option)) *S3API_PutObjectRetentionWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutObjectRetentionInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectRetentionWithContext_Call) Return(_a0 *s3.PutObjectRetentionOutput, _a1 error) *S3API_PutObjectRetentionWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectRetentionWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) (*s3.PutObjectRetentionOutput, error)) *S3API_PutObjectRetentionWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectTagging provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectTagging(_a0 *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectTagging")
-	}
-
-	var r0 *s3.PutObjectTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) *s3.PutObjectTaggingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectTaggingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTagging'
-type S3API_PutObjectTagging_Call struct {
-	*mock.Call
-}
-
-// PutObjectTagging is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectTaggingInput
-func (_e *S3API_Expecter) PutObjectTagging(_a0 interface{}) *S3API_PutObjectTagging_Call {
-	return &S3API_PutObjectTagging_Call{Call: _e.mock.On("PutObjectTagging", _a0)}
-}
-
-func (_c *S3API_PutObjectTagging_Call) Run(run func(_a0 *s3.PutObjectTaggingInput)) *S3API_PutObjectTagging_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectTagging_Call) Return(_a0 *s3.PutObjectTaggingOutput, _a1 error) *S3API_PutObjectTagging_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectTagging_Call) RunAndReturn(run func(*s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error)) *S3API_PutObjectTagging_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectTaggingRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutObjectTaggingRequest(_a0 *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectTaggingRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutObjectTaggingOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutObjectTaggingInput) *s3.PutObjectTaggingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutObjectTaggingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTaggingRequest'
-type S3API_PutObjectTaggingRequest_Call struct {
-	*mock.Call
-}
-
-// PutObjectTaggingRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutObjectTaggingInput
-func (_e *S3API_Expecter) PutObjectTaggingRequest(_a0 interface{}) *S3API_PutObjectTaggingRequest_Call {
-	return &S3API_PutObjectTaggingRequest_Call{Call: _e.mock.On("PutObjectTaggingRequest", _a0)}
-}
-
-func (_c *S3API_PutObjectTaggingRequest_Call) Run(run func(_a0 *s3.PutObjectTaggingInput)) *S3API_PutObjectTaggingRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutObjectTaggingInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectTaggingRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutObjectTaggingOutput) *S3API_PutObjectTaggingRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectTaggingRequest_Call) RunAndReturn(run func(*s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput)) *S3API_PutObjectTaggingRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutObjectTaggingWithContext(_a0 aws.Context, _a1 *s3.PutObjectTaggingInput, _a2 ...request.Option) (*s3.PutObjectTaggingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectTaggingWithContext")
-	}
-
-	var r0 *s3.PutObjectTaggingOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) (*s3.PutObjectTaggingOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) *s3.PutObjectTaggingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectTaggingOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTaggingWithContext'
-type S3API_PutObjectTaggingWithContext_Call struct {
-	*mock.Call
-}
-
-// PutObjectTaggingWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutObjectTaggingInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutObjectTaggingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutObjectTaggingWithContext_Call {
-	return &S3API_PutObjectTaggingWithContext_Call{Call: _e.mock.On("PutObjectTaggingWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutObjectTaggingWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutObjectTaggingInput, _a2 ...request.Option)) *S3API_PutObjectTaggingWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutObjectTaggingInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectTaggingWithContext_Call) Return(_a0 *s3.PutObjectTaggingOutput, _a1 error) *S3API_PutObjectTaggingWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectTaggingWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) (*s3.PutObjectTaggingOutput, error)) *S3API_PutObjectTaggingWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutObjectWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutObjectWithContext(_a0 aws.Context, _a1 *s3.PutObjectInput, _a2 ...request.Option) (*s3.PutObjectOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutObjectWithContext")
-	}
-
-	var r0 *s3.PutObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectInput, ...request.Option) (*s3.PutObjectOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectInput, ...request.Option) *s3.PutObjectOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectWithContext'
-type S3API_PutObjectWithContext_Call struct {
-	*mock.Call
-}
-
-// PutObjectWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutObjectInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutObjectWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutObjectWithContext_Call {
-	return &S3API_PutObjectWithContext_Call{Call: _e.mock.On("PutObjectWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutObjectWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutObjectInput, _a2 ...request.Option)) *S3API_PutObjectWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutObjectWithContext_Call) Return(_a0 *s3.PutObjectOutput, _a1 error) *S3API_PutObjectWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutObjectWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutObjectInput, ...request.Option) (*s3.PutObjectOutput, error)) *S3API_PutObjectWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutPublicAccessBlock provides a mock function with given fields: _a0
-func (_m *S3API) PutPublicAccessBlock(_a0 *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutPublicAccessBlock")
-	}
-
-	var r0 *s3.PutPublicAccessBlockOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) *s3.PutPublicAccessBlockOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutPublicAccessBlockOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutPublicAccessBlockInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutPublicAccessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutPublicAccessBlock'
-type S3API_PutPublicAccessBlock_Call struct {
-	*mock.Call
-}
-
-// PutPublicAccessBlock is a helper method to define mock.On call
-//   - _a0 *s3.PutPublicAccessBlockInput
-func (_e *S3API_Expecter) PutPublicAccessBlock(_a0 interface{}) *S3API_PutPublicAccessBlock_Call {
-	return &S3API_PutPublicAccessBlock_Call{Call: _e.mock.On("PutPublicAccessBlock", _a0)}
-}
-
-func (_c *S3API_PutPublicAccessBlock_Call) Run(run func(_a0 *s3.PutPublicAccessBlockInput)) *S3API_PutPublicAccessBlock_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutPublicAccessBlockInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutPublicAccessBlock_Call) Return(_a0 *s3.PutPublicAccessBlockOutput, _a1 error) *S3API_PutPublicAccessBlock_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutPublicAccessBlock_Call) RunAndReturn(run func(*s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error)) *S3API_PutPublicAccessBlock_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutPublicAccessBlockRequest provides a mock function with given fields: _a0
-func (_m *S3API) PutPublicAccessBlockRequest(_a0 *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutPublicAccessBlockRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.PutPublicAccessBlockOutput
-	if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.PutPublicAccessBlockInput) *s3.PutPublicAccessBlockOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.PutPublicAccessBlockOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_PutPublicAccessBlockRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutPublicAccessBlockRequest'
-type S3API_PutPublicAccessBlockRequest_Call struct {
-	*mock.Call
-}
-
-// PutPublicAccessBlockRequest is a helper method to define mock.On call
-//   - _a0 *s3.PutPublicAccessBlockInput
-func (_e *S3API_Expecter) PutPublicAccessBlockRequest(_a0 interface{}) *S3API_PutPublicAccessBlockRequest_Call {
-	return &S3API_PutPublicAccessBlockRequest_Call{Call: _e.mock.On("PutPublicAccessBlockRequest", _a0)}
-}
-
-func (_c *S3API_PutPublicAccessBlockRequest_Call) Run(run func(_a0 *s3.PutPublicAccessBlockInput)) *S3API_PutPublicAccessBlockRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.PutPublicAccessBlockInput))
-	})
-	return _c
-}
-
-func (_c *S3API_PutPublicAccessBlockRequest_Call) Return(_a0 *request.Request, _a1 *s3.PutPublicAccessBlockOutput) *S3API_PutPublicAccessBlockRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutPublicAccessBlockRequest_Call) RunAndReturn(run func(*s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput)) *S3API_PutPublicAccessBlockRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PutPublicAccessBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) PutPublicAccessBlockWithContext(_a0 aws.Context, _a1 *s3.PutPublicAccessBlockInput, _a2 ...request.Option) (*s3.PutPublicAccessBlockOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutPublicAccessBlockWithContext")
-	}
-
-	var r0 *s3.PutPublicAccessBlockOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) (*s3.PutPublicAccessBlockOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) *s3.PutPublicAccessBlockOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.PutPublicAccessBlockOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_PutPublicAccessBlockWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutPublicAccessBlockWithContext'
-type S3API_PutPublicAccessBlockWithContext_Call struct {
-	*mock.Call
-}
-
-// PutPublicAccessBlockWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.PutPublicAccessBlockInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) PutPublicAccessBlockWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_PutPublicAccessBlockWithContext_Call {
-	return &S3API_PutPublicAccessBlockWithContext_Call{Call: _e.mock.On("PutPublicAccessBlockWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_PutPublicAccessBlockWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.PutPublicAccessBlockInput, _a2 ...request.Option)) *S3API_PutPublicAccessBlockWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.PutPublicAccessBlockInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_PutPublicAccessBlockWithContext_Call) Return(_a0 *s3.PutPublicAccessBlockOutput, _a1 error) *S3API_PutPublicAccessBlockWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_PutPublicAccessBlockWithContext_Call) RunAndReturn(run func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) (*s3.PutPublicAccessBlockOutput, error)) *S3API_PutPublicAccessBlockWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RestoreObject provides a mock function with given fields: _a0
-func (_m *S3API) RestoreObject(_a0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RestoreObject")
-	}
-
-	var r0 *s3.RestoreObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) *s3.RestoreObjectOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.RestoreObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.RestoreObjectInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_RestoreObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreObject'
-type S3API_RestoreObject_Call struct {
-	*mock.Call
-}
-
-// RestoreObject is a helper method to define mock.On call
-//   - _a0 *s3.RestoreObjectInput
-func (_e *S3API_Expecter) RestoreObject(_a0 interface{}) *S3API_RestoreObject_Call {
-	return &S3API_RestoreObject_Call{Call: _e.mock.On("RestoreObject", _a0)}
-}
-
-func (_c *S3API_RestoreObject_Call) Run(run func(_a0 *s3.RestoreObjectInput)) *S3API_RestoreObject_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.RestoreObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_RestoreObject_Call) Return(_a0 *s3.RestoreObjectOutput, _a1 error) *S3API_RestoreObject_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_RestoreObject_Call) RunAndReturn(run func(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)) *S3API_RestoreObject_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RestoreObjectRequest provides a mock function with given fields: _a0
-func (_m *S3API) RestoreObjectRequest(_a0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RestoreObjectRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.RestoreObjectOutput
-	if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.RestoreObjectInput) *s3.RestoreObjectOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.RestoreObjectOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_RestoreObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreObjectRequest'
-type S3API_RestoreObjectRequest_Call struct {
-	*mock.Call
-}
-
-// RestoreObjectRequest is a helper method to define mock.On call
-//   - _a0 *s3.RestoreObjectInput
-func (_e *S3API_Expecter) RestoreObjectRequest(_a0 interface{}) *S3API_RestoreObjectRequest_Call {
-	return &S3API_RestoreObjectRequest_Call{Call: _e.mock.On("RestoreObjectRequest", _a0)}
-}
-
-func (_c *S3API_RestoreObjectRequest_Call) Run(run func(_a0 *s3.RestoreObjectInput)) *S3API_RestoreObjectRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.RestoreObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_RestoreObjectRequest_Call) Return(_a0 *request.Request, _a1 *s3.RestoreObjectOutput) *S3API_RestoreObjectRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_RestoreObjectRequest_Call) RunAndReturn(run func(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)) *S3API_RestoreObjectRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RestoreObjectWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) RestoreObjectWithContext(_a0 aws.Context, _a1 *s3.RestoreObjectInput, _a2 ...request.Option) (*s3.RestoreObjectOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RestoreObjectWithContext")
-	}
-
-	var r0 *s3.RestoreObjectOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.RestoreObjectInput, ...request.Option) (*s3.RestoreObjectOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.RestoreObjectInput, ...request.Option) *s3.RestoreObjectOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.RestoreObjectOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.RestoreObjectInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_RestoreObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreObjectWithContext'
-type S3API_RestoreObjectWithContext_Call struct {
-	*mock.Call
-}
-
-// RestoreObjectWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.RestoreObjectInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) RestoreObjectWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_RestoreObjectWithContext_Call {
-	return &S3API_RestoreObjectWithContext_Call{Call: _e.mock.On("RestoreObjectWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_RestoreObjectWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.RestoreObjectInput, _a2 ...request.Option)) *S3API_RestoreObjectWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.RestoreObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_RestoreObjectWithContext_Call) Return(_a0 *s3.RestoreObjectOutput, _a1 error) *S3API_RestoreObjectWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_RestoreObjectWithContext_Call) RunAndReturn(run func(aws.Context, *s3.RestoreObjectInput, ...request.Option) (*s3.RestoreObjectOutput, error)) *S3API_RestoreObjectWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SelectObjectContent provides a mock function with given fields: _a0
-func (_m *S3API) SelectObjectContent(_a0 *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SelectObjectContent")
-	}
-
-	var r0 *s3.SelectObjectContentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) *s3.SelectObjectContentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.SelectObjectContentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.SelectObjectContentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_SelectObjectContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectObjectContent'
-type S3API_SelectObjectContent_Call struct {
-	*mock.Call
-}
-
-// SelectObjectContent is a helper method to define mock.On call
-//   - _a0 *s3.SelectObjectContentInput
-func (_e *S3API_Expecter) SelectObjectContent(_a0 interface{}) *S3API_SelectObjectContent_Call {
-	return &S3API_SelectObjectContent_Call{Call: _e.mock.On("SelectObjectContent", _a0)}
-}
-
-func (_c *S3API_SelectObjectContent_Call) Run(run func(_a0 *s3.SelectObjectContentInput)) *S3API_SelectObjectContent_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.SelectObjectContentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_SelectObjectContent_Call) Return(_a0 *s3.SelectObjectContentOutput, _a1 error) *S3API_SelectObjectContent_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_SelectObjectContent_Call) RunAndReturn(run func(*s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error)) *S3API_SelectObjectContent_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SelectObjectContentRequest provides a mock function with given fields: _a0
-func (_m *S3API) SelectObjectContentRequest(_a0 *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SelectObjectContentRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.SelectObjectContentOutput
-	if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.SelectObjectContentInput) *s3.SelectObjectContentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.SelectObjectContentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_SelectObjectContentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectObjectContentRequest'
-type S3API_SelectObjectContentRequest_Call struct {
-	*mock.Call
-}
-
-// SelectObjectContentRequest is a helper method to define mock.On call
-//   - _a0 *s3.SelectObjectContentInput
-func (_e *S3API_Expecter) SelectObjectContentRequest(_a0 interface{}) *S3API_SelectObjectContentRequest_Call {
-	return &S3API_SelectObjectContentRequest_Call{Call: _e.mock.On("SelectObjectContentRequest", _a0)}
-}
-
-func (_c *S3API_SelectObjectContentRequest_Call) Run(run func(_a0 *s3.SelectObjectContentInput)) *S3API_SelectObjectContentRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.SelectObjectContentInput))
-	})
-	return _c
-}
-
-func (_c *S3API_SelectObjectContentRequest_Call) Return(_a0 *request.Request, _a1 *s3.SelectObjectContentOutput) *S3API_SelectObjectContentRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_SelectObjectContentRequest_Call) RunAndReturn(run func(*s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput)) *S3API_SelectObjectContentRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SelectObjectContentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) SelectObjectContentWithContext(_a0 aws.Context, _a1 *s3.SelectObjectContentInput, _a2 ...request.Option) (*s3.SelectObjectContentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SelectObjectContentWithContext")
-	}
-
-	var r0 *s3.SelectObjectContentOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) (*s3.SelectObjectContentOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) *s3.SelectObjectContentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.SelectObjectContentOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_SelectObjectContentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectObjectContentWithContext'
-type S3API_SelectObjectContentWithContext_Call struct {
-	*mock.Call
-}
-
-// SelectObjectContentWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.SelectObjectContentInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) SelectObjectContentWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_SelectObjectContentWithContext_Call {
-	return &S3API_SelectObjectContentWithContext_Call{Call: _e.mock.On("SelectObjectContentWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_SelectObjectContentWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.SelectObjectContentInput, _a2 ...request.Option)) *S3API_SelectObjectContentWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.SelectObjectContentInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_SelectObjectContentWithContext_Call) Return(_a0 *s3.SelectObjectContentOutput, _a1 error) *S3API_SelectObjectContentWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_SelectObjectContentWithContext_Call) RunAndReturn(run func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) (*s3.SelectObjectContentOutput, error)) *S3API_SelectObjectContentWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPart provides a mock function with given fields: _a0
-func (_m *S3API) UploadPart(_a0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPart")
-	}
-
-	var r0 *s3.UploadPartOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) (*s3.UploadPartOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) *s3.UploadPartOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.UploadPartOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.UploadPartInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_UploadPart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPart'
-type S3API_UploadPart_Call struct {
-	*mock.Call
-}
-
-// UploadPart is a helper method to define mock.On call
-//   - _a0 *s3.UploadPartInput
-func (_e *S3API_Expecter) UploadPart(_a0 interface{}) *S3API_UploadPart_Call {
-	return &S3API_UploadPart_Call{Call: _e.mock.On("UploadPart", _a0)}
-}
-
-func (_c *S3API_UploadPart_Call) Run(run func(_a0 *s3.UploadPartInput)) *S3API_UploadPart_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.UploadPartInput))
-	})
-	return _c
-}
-
-func (_c *S3API_UploadPart_Call) Return(_a0 *s3.UploadPartOutput, _a1 error) *S3API_UploadPart_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_UploadPart_Call) RunAndReturn(run func(*s3.UploadPartInput) (*s3.UploadPartOutput, error)) *S3API_UploadPart_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPartCopy provides a mock function with given fields: _a0
-func (_m *S3API) UploadPartCopy(_a0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPartCopy")
-	}
-
-	var r0 *s3.UploadPartCopyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) *s3.UploadPartCopyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.UploadPartCopyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.UploadPartCopyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_UploadPartCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartCopy'
-type S3API_UploadPartCopy_Call struct {
-	*mock.Call
-}
-
-// UploadPartCopy is a helper method to define mock.On call
-//   - _a0 *s3.UploadPartCopyInput
-func (_e *S3API_Expecter) UploadPartCopy(_a0 interface{}) *S3API_UploadPartCopy_Call {
-	return &S3API_UploadPartCopy_Call{Call: _e.mock.On("UploadPartCopy", _a0)}
-}
-
-func (_c *S3API_UploadPartCopy_Call) Run(run func(_a0 *s3.UploadPartCopyInput)) *S3API_UploadPartCopy_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.UploadPartCopyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_UploadPartCopy_Call) Return(_a0 *s3.UploadPartCopyOutput, _a1 error) *S3API_UploadPartCopy_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_UploadPartCopy_Call) RunAndReturn(run func(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)) *S3API_UploadPartCopy_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPartCopyRequest provides a mock function with given fields: _a0
-func (_m *S3API) UploadPartCopyRequest(_a0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPartCopyRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.UploadPartCopyOutput
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.UploadPartCopyInput) *s3.UploadPartCopyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.UploadPartCopyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_UploadPartCopyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartCopyRequest'
-type S3API_UploadPartCopyRequest_Call struct {
-	*mock.Call
-}
-
-// UploadPartCopyRequest is a helper method to define mock.On call
-//   - _a0 *s3.UploadPartCopyInput
-func (_e *S3API_Expecter) UploadPartCopyRequest(_a0 interface{}) *S3API_UploadPartCopyRequest_Call {
-	return &S3API_UploadPartCopyRequest_Call{Call: _e.mock.On("UploadPartCopyRequest", _a0)}
-}
-
-func (_c *S3API_UploadPartCopyRequest_Call) Run(run func(_a0 *s3.UploadPartCopyInput)) *S3API_UploadPartCopyRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.UploadPartCopyInput))
-	})
-	return _c
-}
-
-func (_c *S3API_UploadPartCopyRequest_Call) Return(_a0 *request.Request, _a1 *s3.UploadPartCopyOutput) *S3API_UploadPartCopyRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_UploadPartCopyRequest_Call) RunAndReturn(run func(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)) *S3API_UploadPartCopyRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPartCopyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) UploadPartCopyWithContext(_a0 aws.Context, _a1 *s3.UploadPartCopyInput, _a2 ...request.Option) (*s3.UploadPartCopyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPartCopyWithContext")
-	}
-
-	var r0 *s3.UploadPartCopyOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) (*s3.UploadPartCopyOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) *s3.UploadPartCopyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.UploadPartCopyOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_UploadPartCopyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartCopyWithContext'
-type S3API_UploadPartCopyWithContext_Call struct {
-	*mock.Call
-}
-
-// UploadPartCopyWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.UploadPartCopyInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) UploadPartCopyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_UploadPartCopyWithContext_Call {
-	return &S3API_UploadPartCopyWithContext_Call{Call: _e.mock.On("UploadPartCopyWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_UploadPartCopyWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.UploadPartCopyInput, _a2 ...request.Option)) *S3API_UploadPartCopyWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.UploadPartCopyInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_UploadPartCopyWithContext_Call) Return(_a0 *s3.UploadPartCopyOutput, _a1 error) *S3API_UploadPartCopyWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_UploadPartCopyWithContext_Call) RunAndReturn(run func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) (*s3.UploadPartCopyOutput, error)) *S3API_UploadPartCopyWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPartRequest provides a mock function with given fields: _a0
-func (_m *S3API) UploadPartRequest(_a0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPartRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.UploadPartOutput
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.UploadPartInput) *s3.UploadPartOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.UploadPartOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_UploadPartRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartRequest'
-type S3API_UploadPartRequest_Call struct {
-	*mock.Call
-}
-
-// UploadPartRequest is a helper method to define mock.On call
-//   - _a0 *s3.UploadPartInput
-func (_e *S3API_Expecter) UploadPartRequest(_a0 interface{}) *S3API_UploadPartRequest_Call {
-	return &S3API_UploadPartRequest_Call{Call: _e.mock.On("UploadPartRequest", _a0)}
-}
-
-func (_c *S3API_UploadPartRequest_Call) Run(run func(_a0 *s3.UploadPartInput)) *S3API_UploadPartRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.UploadPartInput))
-	})
-	return _c
-}
-
-func (_c *S3API_UploadPartRequest_Call) Return(_a0 *request.Request, _a1 *s3.UploadPartOutput) *S3API_UploadPartRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_UploadPartRequest_Call) RunAndReturn(run func(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)) *S3API_UploadPartRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadPartWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) UploadPartWithContext(_a0 aws.Context, _a1 *s3.UploadPartInput, _a2 ...request.Option) (*s3.UploadPartOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadPartWithContext")
-	}
-
-	var r0 *s3.UploadPartOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartInput, ...request.Option) (*s3.UploadPartOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartInput, ...request.Option) *s3.UploadPartOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.UploadPartOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.UploadPartInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_UploadPartWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartWithContext'
-type S3API_UploadPartWithContext_Call struct {
-	*mock.Call
-}
-
-// UploadPartWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.UploadPartInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) UploadPartWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_UploadPartWithContext_Call {
-	return &S3API_UploadPartWithContext_Call{Call: _e.mock.On("UploadPartWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_UploadPartWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.UploadPartInput, _a2 ...request.Option)) *S3API_UploadPartWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.UploadPartInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_UploadPartWithContext_Call) Return(_a0 *s3.UploadPartOutput, _a1 error) *S3API_UploadPartWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_UploadPartWithContext_Call) RunAndReturn(run func(aws.Context, *s3.UploadPartInput, ...request.Option) (*s3.UploadPartOutput, error)) *S3API_UploadPartWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilBucketExists provides a mock function with given fields: _a0
-func (_m *S3API) WaitUntilBucketExists(_a0 *s3.HeadBucketInput) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilBucketExists")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilBucketExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketExists'
-type S3API_WaitUntilBucketExists_Call struct {
-	*mock.Call
-}
-
-// WaitUntilBucketExists is a helper method to define mock.On call
-//   - _a0 *s3.HeadBucketInput
-func (_e *S3API_Expecter) WaitUntilBucketExists(_a0 interface{}) *S3API_WaitUntilBucketExists_Call {
-	return &S3API_WaitUntilBucketExists_Call{Call: _e.mock.On("WaitUntilBucketExists", _a0)}
-}
-
-func (_c *S3API_WaitUntilBucketExists_Call) Run(run func(_a0 *s3.HeadBucketInput)) *S3API_WaitUntilBucketExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketExists_Call) Return(_a0 error) *S3API_WaitUntilBucketExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketExists_Call) RunAndReturn(run func(*s3.HeadBucketInput) error) *S3API_WaitUntilBucketExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilBucketExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) WaitUntilBucketExistsWithContext(_a0 aws.Context, _a1 *s3.HeadBucketInput, _a2 ...request.WaiterOption) error {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilBucketExistsWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.WaiterOption) error); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilBucketExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketExistsWithContext'
-type S3API_WaitUntilBucketExistsWithContext_Call struct {
-	*mock.Call
-}
-
-// WaitUntilBucketExistsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.HeadBucketInput
-//   - _a2 ...request.WaiterOption
-func (_e *S3API_Expecter) WaitUntilBucketExistsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_WaitUntilBucketExistsWithContext_Call {
-	return &S3API_WaitUntilBucketExistsWithContext_Call{Call: _e.mock.On("WaitUntilBucketExistsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_WaitUntilBucketExistsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.HeadBucketInput, _a2 ...request.WaiterOption)) *S3API_WaitUntilBucketExistsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.WaiterOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.WaiterOption)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.HeadBucketInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketExistsWithContext_Call) Return(_a0 error) *S3API_WaitUntilBucketExistsWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketExistsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.HeadBucketInput, ...request.WaiterOption) error) *S3API_WaitUntilBucketExistsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilBucketNotExists provides a mock function with given fields: _a0
-func (_m *S3API) WaitUntilBucketNotExists(_a0 *s3.HeadBucketInput) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilBucketNotExists")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilBucketNotExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketNotExists'
-type S3API_WaitUntilBucketNotExists_Call struct {
-	*mock.Call
-}
-
-// WaitUntilBucketNotExists is a helper method to define mock.On call
-//   - _a0 *s3.HeadBucketInput
-func (_e *S3API_Expecter) WaitUntilBucketNotExists(_a0 interface{}) *S3API_WaitUntilBucketNotExists_Call {
-	return &S3API_WaitUntilBucketNotExists_Call{Call: _e.mock.On("WaitUntilBucketNotExists", _a0)}
-}
-
-func (_c *S3API_WaitUntilBucketNotExists_Call) Run(run func(_a0 *s3.HeadBucketInput)) *S3API_WaitUntilBucketNotExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadBucketInput))
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketNotExists_Call) Return(_a0 error) *S3API_WaitUntilBucketNotExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketNotExists_Call) RunAndReturn(run func(*s3.HeadBucketInput) error) *S3API_WaitUntilBucketNotExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilBucketNotExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) WaitUntilBucketNotExistsWithContext(_a0 aws.Context, _a1 *s3.HeadBucketInput, _a2 ...request.WaiterOption) error {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilBucketNotExistsWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.WaiterOption) error); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilBucketNotExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketNotExistsWithContext'
-type S3API_WaitUntilBucketNotExistsWithContext_Call struct {
-	*mock.Call
-}
-
-// WaitUntilBucketNotExistsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.HeadBucketInput
-//   - _a2 ...request.WaiterOption
-func (_e *S3API_Expecter) WaitUntilBucketNotExistsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_WaitUntilBucketNotExistsWithContext_Call {
-	return &S3API_WaitUntilBucketNotExistsWithContext_Call{Call: _e.mock.On("WaitUntilBucketNotExistsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_WaitUntilBucketNotExistsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.HeadBucketInput, _a2 ...request.WaiterOption)) *S3API_WaitUntilBucketNotExistsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.WaiterOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.WaiterOption)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.HeadBucketInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketNotExistsWithContext_Call) Return(_a0 error) *S3API_WaitUntilBucketNotExistsWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilBucketNotExistsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.HeadBucketInput, ...request.WaiterOption) error) *S3API_WaitUntilBucketNotExistsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilObjectExists provides a mock function with given fields: _a0
-func (_m *S3API) WaitUntilObjectExists(_a0 *s3.HeadObjectInput) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilObjectExists")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilObjectExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectExists'
-type S3API_WaitUntilObjectExists_Call struct {
-	*mock.Call
-}
-
-// WaitUntilObjectExists is a helper method to define mock.On call
-//   - _a0 *s3.HeadObjectInput
-func (_e *S3API_Expecter) WaitUntilObjectExists(_a0 interface{}) *S3API_WaitUntilObjectExists_Call {
-	return &S3API_WaitUntilObjectExists_Call{Call: _e.mock.On("WaitUntilObjectExists", _a0)}
-}
-
-func (_c *S3API_WaitUntilObjectExists_Call) Run(run func(_a0 *s3.HeadObjectInput)) *S3API_WaitUntilObjectExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectExists_Call) Return(_a0 error) *S3API_WaitUntilObjectExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectExists_Call) RunAndReturn(run func(*s3.HeadObjectInput) error) *S3API_WaitUntilObjectExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilObjectExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) WaitUntilObjectExistsWithContext(_a0 aws.Context, _a1 *s3.HeadObjectInput, _a2 ...request.WaiterOption) error {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilObjectExistsWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.WaiterOption) error); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilObjectExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectExistsWithContext'
-type S3API_WaitUntilObjectExistsWithContext_Call struct {
-	*mock.Call
-}
-
-// WaitUntilObjectExistsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.HeadObjectInput
-//   - _a2 ...request.WaiterOption
-func (_e *S3API_Expecter) WaitUntilObjectExistsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_WaitUntilObjectExistsWithContext_Call {
-	return &S3API_WaitUntilObjectExistsWithContext_Call{Call: _e.mock.On("WaitUntilObjectExistsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_WaitUntilObjectExistsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.HeadObjectInput, _a2 ...request.WaiterOption)) *S3API_WaitUntilObjectExistsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.WaiterOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.WaiterOption)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.HeadObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectExistsWithContext_Call) Return(_a0 error) *S3API_WaitUntilObjectExistsWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectExistsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.HeadObjectInput, ...request.WaiterOption) error) *S3API_WaitUntilObjectExistsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilObjectNotExists provides a mock function with given fields: _a0
-func (_m *S3API) WaitUntilObjectNotExists(_a0 *s3.HeadObjectInput) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilObjectNotExists")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilObjectNotExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectNotExists'
-type S3API_WaitUntilObjectNotExists_Call struct {
-	*mock.Call
-}
-
-// WaitUntilObjectNotExists is a helper method to define mock.On call
-//   - _a0 *s3.HeadObjectInput
-func (_e *S3API_Expecter) WaitUntilObjectNotExists(_a0 interface{}) *S3API_WaitUntilObjectNotExists_Call {
-	return &S3API_WaitUntilObjectNotExists_Call{Call: _e.mock.On("WaitUntilObjectNotExists", _a0)}
-}
-
-func (_c *S3API_WaitUntilObjectNotExists_Call) Run(run func(_a0 *s3.HeadObjectInput)) *S3API_WaitUntilObjectNotExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.HeadObjectInput))
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectNotExists_Call) Return(_a0 error) *S3API_WaitUntilObjectNotExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectNotExists_Call) RunAndReturn(run func(*s3.HeadObjectInput) error) *S3API_WaitUntilObjectNotExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WaitUntilObjectNotExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) WaitUntilObjectNotExistsWithContext(_a0 aws.Context, _a1 *s3.HeadObjectInput, _a2 ...request.WaiterOption) error {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WaitUntilObjectNotExistsWithContext")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.WaiterOption) error); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// S3API_WaitUntilObjectNotExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectNotExistsWithContext'
-type S3API_WaitUntilObjectNotExistsWithContext_Call struct {
-	*mock.Call
-}
-
-// WaitUntilObjectNotExistsWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.HeadObjectInput
-//   - _a2 ...request.WaiterOption
-func (_e *S3API_Expecter) WaitUntilObjectNotExistsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_WaitUntilObjectNotExistsWithContext_Call {
-	return &S3API_WaitUntilObjectNotExistsWithContext_Call{Call: _e.mock.On("WaitUntilObjectNotExistsWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_WaitUntilObjectNotExistsWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.HeadObjectInput, _a2 ...request.WaiterOption)) *S3API_WaitUntilObjectNotExistsWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.WaiterOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.WaiterOption)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.HeadObjectInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectNotExistsWithContext_Call) Return(_a0 error) *S3API_WaitUntilObjectNotExistsWithContext_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *S3API_WaitUntilObjectNotExistsWithContext_Call) RunAndReturn(run func(aws.Context, *s3.HeadObjectInput, ...request.WaiterOption) error) *S3API_WaitUntilObjectNotExistsWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WriteGetObjectResponse provides a mock function with given fields: _a0
-func (_m *S3API) WriteGetObjectResponse(_a0 *s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteGetObjectResponse")
-	}
-
-	var r0 *s3.WriteGetObjectResponseOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) *s3.WriteGetObjectResponseOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.WriteGetObjectResponseOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.WriteGetObjectResponseInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_WriteGetObjectResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteGetObjectResponse'
-type S3API_WriteGetObjectResponse_Call struct {
-	*mock.Call
-}
-
-// WriteGetObjectResponse is a helper method to define mock.On call
-//   - _a0 *s3.WriteGetObjectResponseInput
-func (_e *S3API_Expecter) WriteGetObjectResponse(_a0 interface{}) *S3API_WriteGetObjectResponse_Call {
-	return &S3API_WriteGetObjectResponse_Call{Call: _e.mock.On("WriteGetObjectResponse", _a0)}
-}
-
-func (_c *S3API_WriteGetObjectResponse_Call) Run(run func(_a0 *s3.WriteGetObjectResponseInput)) *S3API_WriteGetObjectResponse_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.WriteGetObjectResponseInput))
-	})
-	return _c
-}
-
-func (_c *S3API_WriteGetObjectResponse_Call) Return(_a0 *s3.WriteGetObjectResponseOutput, _a1 error) *S3API_WriteGetObjectResponse_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_WriteGetObjectResponse_Call) RunAndReturn(run func(*s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error)) *S3API_WriteGetObjectResponse_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WriteGetObjectResponseRequest provides a mock function with given fields: _a0
-func (_m *S3API) WriteGetObjectResponseRequest(_a0 *s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteGetObjectResponseRequest")
-	}
-
-	var r0 *request.Request
-	var r1 *s3.WriteGetObjectResponseOutput
-	if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3.WriteGetObjectResponseInput) *s3.WriteGetObjectResponseOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*s3.WriteGetObjectResponseOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// S3API_WriteGetObjectResponseRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteGetObjectResponseRequest'
-type S3API_WriteGetObjectResponseRequest_Call struct {
-	*mock.Call
-}
-
-// WriteGetObjectResponseRequest is a helper method to define mock.On call
-//   - _a0 *s3.WriteGetObjectResponseInput
-func (_e *S3API_Expecter) WriteGetObjectResponseRequest(_a0 interface{}) *S3API_WriteGetObjectResponseRequest_Call {
-	return &S3API_WriteGetObjectResponseRequest_Call{Call: _e.mock.On("WriteGetObjectResponseRequest", _a0)}
-}
-
-func (_c *S3API_WriteGetObjectResponseRequest_Call) Run(run func(_a0 *s3.WriteGetObjectResponseInput)) *S3API_WriteGetObjectResponseRequest_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*s3.WriteGetObjectResponseInput))
-	})
-	return _c
-}
-
-func (_c *S3API_WriteGetObjectResponseRequest_Call) Return(_a0 *request.Request, _a1 *s3.WriteGetObjectResponseOutput) *S3API_WriteGetObjectResponseRequest_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_WriteGetObjectResponseRequest_Call) RunAndReturn(run func(*s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput)) *S3API_WriteGetObjectResponseRequest_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WriteGetObjectResponseWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *S3API) WriteGetObjectResponseWithContext(_a0 aws.Context, _a1 *s3.WriteGetObjectResponseInput, _a2 ...request.Option) (*s3.WriteGetObjectResponseOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteGetObjectResponseWithContext")
-	}
-
-	var r0 *s3.WriteGetObjectResponseOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) (*s3.WriteGetObjectResponseOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) *s3.WriteGetObjectResponseOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3.WriteGetObjectResponseOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// S3API_WriteGetObjectResponseWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteGetObjectResponseWithContext'
-type S3API_WriteGetObjectResponseWithContext_Call struct {
-	*mock.Call
-}
-
-// WriteGetObjectResponseWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3.WriteGetObjectResponseInput
-//   - _a2 ...request.Option
-func (_e *S3API_Expecter) WriteGetObjectResponseWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *S3API_WriteGetObjectResponseWithContext_Call {
-	return &S3API_WriteGetObjectResponseWithContext_Call{Call: _e.mock.On("WriteGetObjectResponseWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *S3API_WriteGetObjectResponseWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3.WriteGetObjectResponseInput, _a2 ...request.Option)) *S3API_WriteGetObjectResponseWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]request.Option, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(request.Option)
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3.WriteGetObjectResponseInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *S3API_WriteGetObjectResponseWithContext_Call) Return(_a0 *s3.WriteGetObjectResponseOutput, _a1 error) *S3API_WriteGetObjectResponseWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *S3API_WriteGetObjectResponseWithContext_Call) RunAndReturn(run func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) (*s3.WriteGetObjectResponseOutput, error)) *S3API_WriteGetObjectResponseWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewS3API creates a new instance of S3API. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewS3API(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *S3API {
-	mock := &S3API{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/backend/s3/mocks/UploaderAPI.go b/backend/s3/mocks/UploaderAPI.go
deleted file mode 100644
index b0534516..00000000
--- a/backend/s3/mocks/UploaderAPI.go
+++ /dev/null
@@ -1,184 +0,0 @@
-// Code generated by mockery v2.46.3. DO NOT EDIT.
-
-package mocks
-
-import (
-	aws "github.com/aws/aws-sdk-go/aws"
-	mock "github.com/stretchr/testify/mock"
-
-	s3manager "github.com/aws/aws-sdk-go/service/s3/s3manager"
-)
-
-// UploaderAPI is an autogenerated mock type for the UploaderAPI type
-type UploaderAPI struct {
-	mock.Mock
-}
-
-type UploaderAPI_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *UploaderAPI) EXPECT() *UploaderAPI_Expecter {
-	return &UploaderAPI_Expecter{mock: &_m.Mock}
-}
-
-// Upload provides a mock function with given fields: _a0, _a1
-func (_m *UploaderAPI) Upload(_a0 *s3manager.UploadInput, _a1 ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
-	_va := make([]interface{}, len(_a1))
-	for _i := range _a1 {
-		_va[_i] = _a1[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Upload")
-	}
-
-	var r0 *s3manager.UploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)); ok {
-		return rf(_a0, _a1...)
-	}
-	if rf, ok := ret.Get(0).(func(*s3manager.UploadInput, ...func(*s3manager.Uploader)) *s3manager.UploadOutput); ok {
-		r0 = rf(_a0, _a1...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3manager.UploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*s3manager.UploadInput, ...func(*s3manager.Uploader)) error); ok {
-		r1 = rf(_a0, _a1...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UploaderAPI_Upload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upload'
-type UploaderAPI_Upload_Call struct {
-	*mock.Call
-}
-
-// Upload is a helper method to define mock.On call
-//   - _a0 *s3manager.UploadInput
-//   - _a1 ...func(*s3manager.Uploader)
-func (_e *UploaderAPI_Expecter) Upload(_a0 interface{}, _a1 ...interface{}) *UploaderAPI_Upload_Call {
-	return &UploaderAPI_Upload_Call{Call: _e.mock.On("Upload",
-		append([]interface{}{_a0}, _a1...)...)}
-}
-
-func (_c *UploaderAPI_Upload_Call) Run(run func(_a0 *s3manager.UploadInput, _a1 ...func(*s3manager.Uploader))) *UploaderAPI_Upload_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]func(*s3manager.Uploader), len(args)-1)
-		for i, a := range args[1:] {
-			if a != nil {
-				variadicArgs[i] = a.(func(*s3manager.Uploader))
-			}
-		}
-		run(args[0].(*s3manager.UploadInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *UploaderAPI_Upload_Call) Return(_a0 *s3manager.UploadOutput, _a1 error) *UploaderAPI_Upload_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *UploaderAPI_Upload_Call) RunAndReturn(run func(*s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)) *UploaderAPI_Upload_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// UploadWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *UploaderAPI) UploadWithContext(_a0 aws.Context, _a1 *s3manager.UploadInput, _a2 ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for UploadWithContext")
-	}
-
-	var r0 *s3manager.UploadOutput
-	var r1 error
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)); ok {
-		return rf(_a0, _a1, _a2...)
-	}
-	if rf, ok := ret.Get(0).(func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) *s3manager.UploadOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*s3manager.UploadOutput)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UploaderAPI_UploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadWithContext'
-type UploaderAPI_UploadWithContext_Call struct {
-	*mock.Call
-}
-
-// UploadWithContext is a helper method to define mock.On call
-//   - _a0 aws.Context
-//   - _a1 *s3manager.UploadInput
-//   - _a2 ...func(*s3manager.Uploader)
-func (_e *UploaderAPI_Expecter) UploadWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *UploaderAPI_UploadWithContext_Call {
-	return &UploaderAPI_UploadWithContext_Call{Call: _e.mock.On("UploadWithContext",
-		append([]interface{}{_a0, _a1}, _a2...)...)}
-}
-
-func (_c *UploaderAPI_UploadWithContext_Call) Run(run func(_a0 aws.Context, _a1 *s3manager.UploadInput, _a2 ...func(*s3manager.Uploader))) *UploaderAPI_UploadWithContext_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]func(*s3manager.Uploader), len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(func(*s3manager.Uploader))
-			}
-		}
-		run(args[0].(aws.Context), args[1].(*s3manager.UploadInput), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *UploaderAPI_UploadWithContext_Call) Return(_a0 *s3manager.UploadOutput, _a1 error) *UploaderAPI_UploadWithContext_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *UploaderAPI_UploadWithContext_Call) RunAndReturn(run func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)) *UploaderAPI_UploadWithContext_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewUploaderAPI creates a new instance of UploaderAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewUploaderAPI(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *UploaderAPI {
-	mock := &UploaderAPI{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/backend/s3/options.go b/backend/s3/options.go
index f859a07a..93f475d3 100644
--- a/backend/s3/options.go
+++ b/backend/s3/options.go
@@ -1,137 +1,62 @@
 package s3
 
 import (
-	"net/http"
-	"os"
-	"time"
+	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
-	"github.com/aws/aws-sdk-go/aws/defaults"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
 )
 
 // Options holds s3-specific options.  Currently only client options are used.
 type Options struct {
-	AccessKeyID                 string `json:"accessKeyId,omitempty"`
-	SecretAccessKey             string `json:"secretAccessKey,omitempty"`
-	SessionToken                string `json:"sessionToken,omitempty"`
-	Region                      string `json:"region,omitempty"`
-	Endpoint                    string `json:"endpoint,omitempty"`
-	ACL                         string `json:"acl,omitempty"`
-	ForcePathStyle              bool   `json:"forcePathStyle,omitempty"`
-	DisableServerSideEncryption bool   `json:"disableServerSideEncryption,omitempty"`
-	Retry                       request.Retryer
+	AccessKeyID                 string                `json:"accessKeyId,omitempty"`
+	SecretAccessKey             string                `json:"secretAccessKey,omitempty"`
+	SessionToken                string                `json:"sessionToken,omitempty"`
+	Region                      string                `json:"region,omitempty"`
+	Endpoint                    string                `json:"endpoint,omitempty"`
+	ACL                         types.ObjectCannedACL `json:"acl,omitempty"`
+	ForcePathStyle              bool                  `json:"forcePathStyle,omitempty"`
+	DisableServerSideEncryption bool                  `json:"disableServerSideEncryption,omitempty"`
+	Retry                       aws.Retryer
 	MaxRetries                  int
 	FileBufferSize              int   // Buffer size in bytes used with utils.TouchCopyBuffered
-	DownloadPartitionSize       int64 // Partition size in bytes used to multipart download of large files using s3manager.Downloader
-	UploadPartitionSize         int64 // Partition size in bytes used to multipart upload of large files using s3manager.Uploader
+	DownloadPartitionSize       int64 // Partition size in bytes used to multipart download of large files using manager.Downloader
+	UploadPartitionSize         int64 // Partition size in bytes used to multipart upload of large files using manager.Uploader
 }
 
 // getClient setup S3 client
-func getClient(opt Options) (s3iface.S3API, error) {
+func getClient(opt Options) (Client, error) {
 	// setup default config
-	awsConfig := defaults.Config()
-
-	// setup region using opt or env
-	if opt.Region != "" {
-		awsConfig.WithRegion(opt.Region)
-	} else if val, ok := os.LookupEnv("AWS_DEFAULT_REGION"); ok {
-		awsConfig.WithRegion(val)
-	}
-
-	// set filepath for minio users
-	if opt.ForcePathStyle {
-		awsConfig.S3ForcePathStyle = &opt.ForcePathStyle
-	}
-
-	// use specific endpoint, otherwise, will use aws "default endpoint resolver" based on region
-	awsConfig.WithEndpoint(opt.Endpoint)
-
-	if opt.Retry != nil {
-		awsConfig.Retryer = opt.Retry
-	}
-
-	// set up credential provider chain
-	credentialProviders, err := initCredentialProviderChain(opt)
-	if err != nil {
-		return nil, err
-	}
-	awsConfig.WithCredentials(
-		credentials.NewChainCredentials(credentialProviders),
-	)
-
-	// create new session with config
-	s, err := session.NewSessionWithOptions(
-		session.Options{
-			Config: *awsConfig,
-		},
-	)
+	awsConfig, err := config.LoadDefaultConfig(context.Background())
 	if err != nil {
 		return nil, err
 	}
 
 	// return client instance
-	return s3.New(s), nil
-}
-
-// initCredentialProviderChain returns an array of credential providers that will be used, in order, to attempt authentication
-func initCredentialProviderChain(opt Options) ([]credentials.Provider, error) {
-	p := make([]credentials.Provider, 0)
-
-	// A StaticProvider is a set of credentials which are set programmatically,
-	// and will never expire.
-	if opt.AccessKeyID != "" && opt.SecretAccessKey != "" {
-		// Make the auth
-		v := credentials.Value{
-			AccessKeyID:     opt.AccessKeyID,
-			SecretAccessKey: opt.SecretAccessKey,
-			SessionToken:    opt.SessionToken,
+	return s3.NewFromConfig(awsConfig, func(opts *s3.Options) {
+		if opt.Region != "" {
+			opts.Region = opt.Region
 		}
-		p = append(p, &credentials.StaticProvider{Value: v})
-	}
-
-	// A EnvProvider retrieves credentials from the environment variables of the
-	// running process. Environment credentials never expire.
-	//
-	// Environment variables used:
-	//
-	// * Access Key ID:     AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY
-	//
-	// * Secret Access Key: AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY
-	p = append(p, &credentials.EnvProvider{}) //nolint:gocritic // appendCombine
-
-	// Path to the shared credentials file.
-	//
-	// SharedCredentialsProvider will look for "AWS_SHARED_CREDENTIALS_FILE" env variable. If the
-	// env value is empty will default to current user's home directory.
-	// Linux/OSX: "$HOME/.aws/credentials"
-	// Windows:   "%USERPROFILE%\.aws\credentials"
-	p = append(p, &credentials.SharedCredentialsProvider{})
 
-	lowTimeoutClient := &http.Client{Timeout: 1 * time.Second} // low timeout to ec2 metadata service
+		// set filepath for minio users
+		opts.UsePathStyle = opt.ForcePathStyle
 
-	// RemoteCredProvider for default remote endpoints such as EC2 or ECS IAM Roles
-	def := defaults.Get()
-	def.Config.HTTPClient = lowTimeoutClient
-	p = append(p, defaults.RemoteCredProvider(*def.Config, def.Handlers))
+		// use specific endpoint, otherwise, will use aws "default endpoint resolver" based on region
+		if opt.Endpoint != "" {
+			opts.BaseEndpoint = aws.String(opt.Endpoint)
+		}
 
-	// EC2RoleProvider retrieves credentials from the EC2 service, and keeps track if those credentials are expired
-	sess, err := session.NewSession()
-	if err != nil {
-		return nil, err
-	}
-	p = append(p, &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(sess, &aws.Config{
-			HTTPClient: lowTimeoutClient,
-		}),
-		ExpiryWindow: 3,
-	})
+		opts.Retryer = opt.Retry
 
-	return p, nil
+		if opt.AccessKeyID != "" && opt.SecretAccessKey != "" {
+			opts.Credentials = credentials.NewStaticCredentialsProvider(
+				opt.AccessKeyID,
+				opt.SecretAccessKey,
+				opt.SessionToken,
+			)
+		}
+	}), nil
 }
diff --git a/backend/s3/options_test.go b/backend/s3/options_test.go
index 0ae6a9fe..860861ba 100644
--- a/backend/s3/options_test.go
+++ b/backend/s3/options_test.go
@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/stretchr/testify/suite"
 )
 
@@ -22,7 +22,7 @@ func (o *optionsTestSuite) TestGetClient() {
 	client, err := getClient(opts)
 	o.NoError(err)
 	o.NotNil(client, "client is set")
-	o.Empty(*client.(*s3.S3).Config.Region, "config is empty")
+	o.Empty(client.(*s3.Client).Options().Region, "config is empty")
 
 	// options set
 	opts = Options{
@@ -34,8 +34,8 @@ func (o *optionsTestSuite) TestGetClient() {
 	client, err = getClient(opts)
 	o.NoError(err)
 	o.NotNil(client, "client is set")
-	o.Equal("some-region", *client.(*s3.S3).Config.Region, "region is set")
-	o.Truef(*client.(*s3.S3).Config.S3ForcePathStyle, "region is set")
+	o.Equal("some-region", client.(*s3.Client).Options().Region, "region is set")
+	o.Truef(client.(*s3.Client).Options().UsePathStyle, "region is set")
 
 	// env var
 	_ = os.Setenv("AWS_DEFAULT_REGION", "set-by-envvar")
@@ -43,7 +43,7 @@ func (o *optionsTestSuite) TestGetClient() {
 	client, err = getClient(opts)
 	o.NoError(err)
 	o.NotNil(client, "client is set")
-	o.Equal("set-by-envvar", *client.(*s3.S3).Config.Region, "region is set by env var")
+	o.Equal("set-by-envvar", client.(*s3.Client).Options().Region, "region is set by env var")
 }
 
 func TestOptions(t *testing.T) {
diff --git a/docs/s3.md b/docs/s3.md
index 95a2c277..f1eb621e 100644
--- a/docs/s3.md
+++ b/docs/s3.md
@@ -53,12 +53,12 @@ use the following:
         )
 
         // to pass specific client, for instance a mock client
-        s3apiMock := &mocks.S3API{}
-        s3apiMock.On("GetObject", mock.AnythingOfType("*s3.GetObjectInput")).
+        s3cliMock := &mocks.Client{}
+        s3cliMock.On("GetObject", matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
             Return(&s3.GetObjectOutput{
                 Body: nopCloser{bytes.NewBufferString("Hello world!")},
                 }, nil)
-        fs = fs.WithClient(s3apiMock)
+        fs = fs.WithClient(s3cliMock)
     }
 ```
 
@@ -96,7 +96,7 @@ https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html
 
 ### See Also
 
-See: https://github.com/aws/aws-sdk-go/tree/master/service/s3
+See: https://github.com/aws/aws-sdk-go-v2/tree/main/service/s3
 
 ## Usage
 
@@ -257,7 +257,7 @@ func (f *File) Write(data []byte) (res int, err error)
 ```
 Write implements the standard for [io.Writer](https://godoc.org/io#Writer). A buffer is added to with each
 subsequent write. When [f.Close()](#func-file-close) is called, the contents of the buffer are used
-to initiate the PutObject to s3. The underlying implementation uses s3manager
+to initiate the PutObject to s3. The underlying implementation uses manager
 which will determine whether it is appropriate to call PutObject, or initiate a
 multi-part upload.
 
@@ -275,13 +275,13 @@ FileSystem implements vfs.FileSystem for the S3 file system.
 ```go
 func NewFileSystem() *FileSystem
 ```
-NewFileSystem initializer for FileSystem struct accepts s3.Client, a local subset of aws-sdk s3.S3API
-client and returns FileSystem or error.
+NewFileSystem initializer for FileSystem struct accepts s3.Client, a local subset of aws-sdk s3.Client
+and returns FileSystem or error.
 
 #### func (*FileSystem) Client
 
 ```go
-func (fs *FileSystem) Client() (s3.S3API, error)
+func (fs *FileSystem) Client() (Client, error)
 ```
 Client returns the underlying aws s3 client, creating it, if necessary
 See [Authentication](#authentication) for authentication resolution
diff --git a/go.mod b/go.mod
index a46c368b..a6679f63 100644
--- a/go.mod
+++ b/go.mod
@@ -9,7 +9,11 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0
 	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.5.0
-	github.com/aws/aws-sdk-go v1.55.5
+	github.com/aws/aws-sdk-go-v2 v1.32.2
+	github.com/aws/aws-sdk-go-v2/config v1.28.0
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.41
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.33
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.66.0
 	github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349
 	github.com/fatih/color v1.18.0
 	github.com/fsouza/fake-gcs-server v1.52.0
@@ -36,6 +40,20 @@ require (
 	github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.25.0 // indirect
 	github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.49.0 // indirect
 	github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.49.0 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.17 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.21 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.4.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.24.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.32.2 // indirect
+	github.com/aws/smithy-go v1.22.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/cncf/xds/go v0.0.0-20241223141626-cff3c89139a3 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
@@ -58,7 +76,6 @@ require (
 	github.com/gorilla/mux v1.8.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/kr/fs v0.1.0 // indirect
 	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
diff --git a/go.sum b/go.sum
index 59d55397..7a335d2f 100644
--- a/go.sum
+++ b/go.sum
@@ -50,8 +50,44 @@ github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0
 github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.49.0/go.mod h1:l2fIqmwB+FKSfvn3bAD/0i+AXAxhIZjTK2svT/mgUXs=
 github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.49.0 h1:GYUJLfvd++4DMuMhCFLgLXvFwofIxh/qOwoGuS/LTew=
 github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.49.0/go.mod h1:wRbFgBQUVm1YXrvWKofAEmq9HNJTDphbAaJSSX01KUI=
-github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
-github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/aws/aws-sdk-go-v2 v1.32.2 h1:AkNLZEyYMLnx/Q/mSKkcMqwNFXMAvFto9bNsHqcTduI=
+github.com/aws/aws-sdk-go-v2 v1.32.2/go.mod h1:2SK5n0a2karNTv5tbP1SjsX0uhttou00v/HpXKM1ZUo=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6 h1:pT3hpW0cOHRJx8Y0DfJUEQuqPild8jRGmSFmBgvydr0=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6/go.mod h1:j/I2++U0xX+cr44QjHay4Cvxj6FUbnxrgmqN3H1jTZA=
+github.com/aws/aws-sdk-go-v2/config v1.28.0 h1:FosVYWcqEtWNxHn8gB/Vs6jOlNwSoyOCA/g/sxyySOQ=
+github.com/aws/aws-sdk-go-v2/config v1.28.0/go.mod h1:pYhbtvg1siOOg8h5an77rXle9tVG8T+BWLWAo7cOukc=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.41 h1:7gXo+Axmp+R4Z+AK8YFQO0ZV3L0gizGINCOWxSLY9W8=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.41/go.mod h1:u4Eb8d3394YLubphT4jLEwN1rLNq2wFOlT6OuxFwPzU=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.17 h1:TMH3f/SCAWdNtXXVPPu5D6wrr4G5hI1rAxbcocKfC7Q=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.17/go.mod h1:1ZRXLdTpzdJb9fwTMXiLipENRxkGMTn1sfKexGllQCw=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.33 h1:X+4YY5kZRI/cOoSMVMGTqFXHAMg1bvvay7IBcqHpybQ=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.33/go.mod h1:DPynzu+cn92k5UQ6tZhX+wfTB4ah6QDU/NgdHqatmvk=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21 h1:UAsR3xA31QGf79WzpG/ixT9FZvQlh5HY1NRqSHBNOCk=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21/go.mod h1:JNr43NFf5L9YaG3eKTm7HQzls9J+A9YYcGI5Quh1r2Y=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21 h1:6jZVETqmYCadGFvrYEQfC5fAQmlo80CeL5psbno6r0s=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21/go.mod h1:1SR0GbLlnN3QUmYaflZNiH1ql+1qrSiB2vwcJ+4UM60=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 h1:VaRN3TlFdd6KxX1x3ILT5ynH6HvKgqdiXoTxAF4HQcQ=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1/go.mod h1:FbtygfRFze9usAadmnGJNc8KsP346kEe+y2/oyhGAGc=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.21 h1:7edmS3VOBDhK00b/MwGtGglCm7hhwNYnjJs/PgFdMQE=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.21/go.mod h1:Q9o5h4HoIWG8XfzxqiuK/CGUbepCJ8uTlaE3bAbxytQ=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 h1:TToQNkvGguu209puTojY/ozlqy2d/SFNcoLIqTFi42g=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0/go.mod h1:0jp+ltwkf+SwG2fm/PKo8t4y8pJSgOCO4D8Lz3k0aHQ=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.4.2 h1:4FMHqLfk0efmTqhXVRL5xYRqlEBNBiRI7N6w4jsEdd4=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.4.2/go.mod h1:LWoqeWlK9OZeJxsROW2RqrSPvQHKTpp69r/iDjwsSaw=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2 h1:s7NA1SOw8q/5c0wr8477yOPp0z+uBaXBnLE0XYb0POA=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2/go.mod h1:fnjjWyAW/Pj5HYOxl9LJqWtEwS7W2qgcRLWP+uWbss0=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.2 h1:t7iUP9+4wdc5lt3E41huP+GvQZJD38WLsgVp4iOtAjg=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.2/go.mod h1:/niFCtmuQNxqx9v8WAPq5qh7EH25U4BF6tjoyq9bObM=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.66.0 h1:xA6XhTF7PE89BCNHJbQi8VvPzcgMtmGC5dr8S8N7lHk=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.66.0/go.mod h1:cB6oAuus7YXRZhWCc1wIwPywwZ1XwweNp2TVAEGYeB8=
+github.com/aws/aws-sdk-go-v2/service/sso v1.24.2 h1:bSYXVyUzoTHoKalBmwaZxs97HU9DWWI3ehHSAMa7xOk=
+github.com/aws/aws-sdk-go-v2/service/sso v1.24.2/go.mod h1:skMqY7JElusiOUjMJMOv1jJsP7YUg7DrhgqZZWuzu1U=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.2 h1:AhmO1fHINP9vFYUE0LHzCWg/LfUWUF+zFPEcY9QXb7o=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.2/go.mod h1:o8aQygT2+MVP0NaV6kbdE1YnnIM8RRVQzoeUH45GOdI=
+github.com/aws/aws-sdk-go-v2/service/sts v1.32.2 h1:CiS7i0+FUe+/YY1GvIBLLrR/XNGZ4CtM1Ll0XavNuVo=
+github.com/aws/aws-sdk-go-v2/service/sts v1.32.2/go.mod h1:HtaiBI8CjYoNVde8arShXb94UbQQi9L4EMr6D+xGBwo=
+github.com/aws/smithy-go v1.22.0 h1:uunKnWlcoL3zO7q+gG2Pk53joueEOsnNB28QdMsmiMM=
+github.com/aws/smithy-go v1.22.0/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
@@ -169,10 +205,6 @@ github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJS
 github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
 github.com/jlaffaye/ftp v0.2.1-0.20240214224549-4edb16bfcd0f h1:u9Rqt4DbfQ1xc7syxtnWFNU1OjcXJeVYGsiU1q3QAI4=
 github.com/jlaffaye/ftp v0.2.1-0.20240214224549-4edb16bfcd0f/go.mod h1:4p8lUl4vQ80L598CygL+3IFtm+3nggvvW/palOlViwE=
-github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
-github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/keybase/go-keychain v0.0.0-20231219164618-57a3676c3af6 h1:IsMZxCuZqKuao2vNdfD82fjjgPLfyHLpR41Z88viRWs=
 github.com/keybase/go-keychain v0.0.0-20231219164618-57a3676c3af6/go.mod h1:3VeWNIJaW+O5xpRQbPp0Ybqu1vJd/pm7s2F473HRrkw=
 github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
@@ -375,9 +407,7 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/vfssimple/vfssimple_test.go b/vfssimple/vfssimple_test.go
index 3a09c507..d6e26090 100644
--- a/vfssimple/vfssimple_test.go
+++ b/vfssimple/vfssimple_test.go
@@ -293,9 +293,9 @@ func (s *vfsSimpleSuite) TestParseSupportedURI() {
 				// check client for named registered mock
 				switch fs.Scheme() {
 				case "s3":
-					s3api, err := fs.(*s3.FileSystem).Client()
+					s3cli, err := fs.(*s3.FileSystem).Client()
 					s.NoError(err, test.message)
-					if c, ok := s3api.(*namedS3ClientMock); ok {
+					if c, ok := s3cli.(*namedS3ClientMock); ok {
 						s.Equal(c.RegName, test.regFS, test.message)
 					} else {
 						s.Fail("should have returned mock", test.message)
@@ -318,9 +318,9 @@ func (s *vfsSimpleSuite) TestNewFile() {
 	s.NoError(err, "no error expected for NewFile")
 	s.IsType(file, &s3.File{}, "should be an s3.File")
 	s.Equal(file.URI(), goodURI)
-	s3api, err := file.Location().FileSystem().(*s3.FileSystem).Client()
+	s3cli, err := file.Location().FileSystem().(*s3.FileSystem).Client()
 	s.NoError(err, "no error expected")
-	if c, ok := s3api.(*namedS3ClientMock); ok {
+	if c, ok := s3cli.(*namedS3ClientMock); ok {
 		s.Equal(c.RegName, "filetest-path", "should be 'filetest-path', not 'filetest-bucket' or 's3'")
 	} else {
 		s.Fail("should have returned mock", "should not reach this")
@@ -350,9 +350,9 @@ func (s *vfsSimpleSuite) TestNewLocation() {
 	s.NoError(err, "no error expected for NewLocation")
 	s.IsType(loc, &s3.Location{}, "should be an s3.Location")
 	s.Equal(loc.URI(), goodURI)
-	s3api, err := loc.FileSystem().(*s3.FileSystem).Client()
+	s3cli, err := loc.FileSystem().(*s3.FileSystem).Client()
 	s.NoError(err, "no error expected")
-	if c, ok := s3api.(*namedS3ClientMock); ok {
+	if c, ok := s3cli.(*namedS3ClientMock); ok {
 		s.Equal(c.RegName, "loctest-path", "should be 'loctest-path', not 'loctest-bucket' or 's3'")
 	} else {
 		s.Fail("should have returned mock", "should not reach this")
@@ -373,7 +373,7 @@ func (s *vfsSimpleSuite) TestNewLocation() {
 }
 
 type namedS3ClientMock struct {
-	*mocks.S3API
+	*mocks.Client
 	RegName string
 }
 
@@ -381,7 +381,7 @@ type namedS3ClientMock struct {
 // to introspect in the test return
 func getS3NamedClientMock(name string) *namedS3ClientMock {
 	return &namedS3ClientMock{
-		S3API:   &mocks.S3API{},
+		Client:  &mocks.Client{},
 		RegName: name,
 	}
 }