// Automatically generated by MockGen. DO NOT EDIT!
// Source: github.com/aws/aws-sdk-go/service/s3/s3iface (interfaces: S3API)

package s3store_test

import (
	request "github.com/aws/aws-sdk-go/aws/request"
	s3 "github.com/aws/aws-sdk-go/service/s3"
	gomock "github.com/golang/mock/gomock"
)

// Mock of S3API interface
type MockS3API struct {
	ctrl     *gomock.Controller
	recorder *_MockS3APIRecorder
}

// Recorder for MockS3API (not exported)
type _MockS3APIRecorder struct {
	mock *MockS3API
}

func NewMockS3API(ctrl *gomock.Controller) *MockS3API {
	mock := &MockS3API{ctrl: ctrl}
	mock.recorder = &_MockS3APIRecorder{mock}
	return mock
}

func (_m *MockS3API) EXPECT() *_MockS3APIRecorder {
	return _m.recorder
}

func (_m *MockS3API) AbortMultipartUpload(_param0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) {
	ret := _m.ctrl.Call(_m, "AbortMultipartUpload", _param0)
	ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) AbortMultipartUpload(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AbortMultipartUpload", arg0)
}

func (_m *MockS3API) AbortMultipartUploadRequest(_param0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) {
	ret := _m.ctrl.Call(_m, "AbortMultipartUploadRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.AbortMultipartUploadOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) AbortMultipartUploadRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AbortMultipartUploadRequest", arg0)
}

func (_m *MockS3API) CompleteMultipartUpload(_param0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
	ret := _m.ctrl.Call(_m, "CompleteMultipartUpload", _param0)
	ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CompleteMultipartUpload(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CompleteMultipartUpload", arg0)
}

func (_m *MockS3API) CompleteMultipartUploadRequest(_param0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) {
	ret := _m.ctrl.Call(_m, "CompleteMultipartUploadRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CompleteMultipartUploadOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CompleteMultipartUploadRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CompleteMultipartUploadRequest", arg0)
}

func (_m *MockS3API) CopyObject(_param0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
	ret := _m.ctrl.Call(_m, "CopyObject", _param0)
	ret0, _ := ret[0].(*s3.CopyObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CopyObject(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CopyObject", arg0)
}

func (_m *MockS3API) CopyObjectRequest(_param0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) {
	ret := _m.ctrl.Call(_m, "CopyObjectRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CopyObjectOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CopyObjectRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CopyObjectRequest", arg0)
}

func (_m *MockS3API) CreateBucket(_param0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateBucket", _param0)
	ret0, _ := ret[0].(*s3.CreateBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CreateBucket(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateBucket", arg0)
}

func (_m *MockS3API) CreateBucketRequest(_param0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) {
	ret := _m.ctrl.Call(_m, "CreateBucketRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CreateBucketOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CreateBucketRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateBucketRequest", arg0)
}

func (_m *MockS3API) CreateMultipartUpload(_param0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateMultipartUpload", _param0)
	ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CreateMultipartUpload(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateMultipartUpload", arg0)
}

func (_m *MockS3API) CreateMultipartUploadRequest(_param0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) {
	ret := _m.ctrl.Call(_m, "CreateMultipartUploadRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CreateMultipartUploadOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) CreateMultipartUploadRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateMultipartUploadRequest", arg0)
}

func (_m *MockS3API) DeleteBucket(_param0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucket", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucket(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucket", arg0)
}

func (_m *MockS3API) DeleteBucketCors(_param0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucketCors", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketCors(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketCors", arg0)
}

func (_m *MockS3API) DeleteBucketCorsRequest(_param0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketCorsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketCorsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketCorsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketCorsRequest", arg0)
}

func (_m *MockS3API) DeleteBucketLifecycle(_param0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucketLifecycle", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketLifecycle(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketLifecycle", arg0)
}

func (_m *MockS3API) DeleteBucketLifecycleRequest(_param0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketLifecycleRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketLifecycleOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketLifecycleRequest", arg0)
}

func (_m *MockS3API) DeleteBucketPolicy(_param0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucketPolicy", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketPolicy(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketPolicy", arg0)
}

func (_m *MockS3API) DeleteBucketPolicyRequest(_param0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketPolicyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketPolicyOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketPolicyRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketPolicyRequest", arg0)
}

func (_m *MockS3API) DeleteBucketReplication(_param0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucketReplication", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketReplication(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketReplication", arg0)
}

func (_m *MockS3API) DeleteBucketReplicationRequest(_param0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketReplicationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketReplicationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketReplicationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketReplicationRequest", arg0)
}

func (_m *MockS3API) DeleteBucketRequest(_param0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketRequest", arg0)
}

func (_m *MockS3API) DeleteBucketTagging(_param0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucketTagging", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketTagging(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketTagging", arg0)
}

func (_m *MockS3API) DeleteBucketTaggingRequest(_param0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketTaggingRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketTaggingOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketTaggingRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketTaggingRequest", arg0)
}

func (_m *MockS3API) DeleteBucketWebsite(_param0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteBucketWebsite", _param0)
	ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketWebsite(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketWebsite", arg0)
}

func (_m *MockS3API) DeleteBucketWebsiteRequest(_param0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) {
	ret := _m.ctrl.Call(_m, "DeleteBucketWebsiteRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketWebsiteOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketWebsiteRequest", arg0)
}

func (_m *MockS3API) DeleteObject(_param0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteObject", _param0)
	ret0, _ := ret[0].(*s3.DeleteObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteObject(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObject", arg0)
}

func (_m *MockS3API) DeleteObjectRequest(_param0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) {
	ret := _m.ctrl.Call(_m, "DeleteObjectRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteObjectOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteObjectRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObjectRequest", arg0)
}

func (_m *MockS3API) DeleteObjects(_param0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteObjects", _param0)
	ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteObjects(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObjects", arg0)
}

func (_m *MockS3API) DeleteObjectsRequest(_param0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) {
	ret := _m.ctrl.Call(_m, "DeleteObjectsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteObjectsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) DeleteObjectsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObjectsRequest", arg0)
}

func (_m *MockS3API) GetBucketAccelerateConfiguration(_param0 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketAccelerateConfiguration", _param0)
	ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketAccelerateConfiguration", arg0)
}

func (_m *MockS3API) GetBucketAccelerateConfigurationRequest(_param0 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketAccelerateConfigurationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketAccelerateConfigurationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketAccelerateConfigurationRequest", arg0)
}

func (_m *MockS3API) GetBucketAcl(_param0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketAcl", _param0)
	ret0, _ := ret[0].(*s3.GetBucketAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketAcl(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketAcl", arg0)
}

func (_m *MockS3API) GetBucketAclRequest(_param0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketAclRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketAclOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketAclRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketAclRequest", arg0)
}

func (_m *MockS3API) GetBucketCors(_param0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketCors", _param0)
	ret0, _ := ret[0].(*s3.GetBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketCors(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketCors", arg0)
}

func (_m *MockS3API) GetBucketCorsRequest(_param0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketCorsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketCorsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketCorsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketCorsRequest", arg0)
}

func (_m *MockS3API) GetBucketLifecycle(_param0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketLifecycle", _param0)
	ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLifecycle(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycle", arg0)
}

func (_m *MockS3API) GetBucketLifecycleConfiguration(_param0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketLifecycleConfiguration", _param0)
	ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycleConfiguration", arg0)
}

func (_m *MockS3API) GetBucketLifecycleConfigurationRequest(_param0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketLifecycleConfigurationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLifecycleConfigurationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycleConfigurationRequest", arg0)
}

func (_m *MockS3API) GetBucketLifecycleRequest(_param0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketLifecycleRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLifecycleOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycleRequest", arg0)
}

func (_m *MockS3API) GetBucketLocation(_param0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketLocation", _param0)
	ret0, _ := ret[0].(*s3.GetBucketLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLocation(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLocation", arg0)
}

func (_m *MockS3API) GetBucketLocationRequest(_param0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketLocationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLocationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLocationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLocationRequest", arg0)
}

func (_m *MockS3API) GetBucketLogging(_param0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketLogging", _param0)
	ret0, _ := ret[0].(*s3.GetBucketLoggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLogging(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLogging", arg0)
}

func (_m *MockS3API) GetBucketLoggingRequest(_param0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketLoggingRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLoggingOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketLoggingRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLoggingRequest", arg0)
}

func (_m *MockS3API) GetBucketNotification(_param0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) {
	ret := _m.ctrl.Call(_m, "GetBucketNotification", _param0)
	ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketNotification(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotification", arg0)
}

func (_m *MockS3API) GetBucketNotificationConfiguration(_param0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) {
	ret := _m.ctrl.Call(_m, "GetBucketNotificationConfiguration", _param0)
	ret0, _ := ret[0].(*s3.NotificationConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotificationConfiguration", arg0)
}

func (_m *MockS3API) GetBucketNotificationConfigurationRequest(_param0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) {
	ret := _m.ctrl.Call(_m, "GetBucketNotificationConfigurationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.NotificationConfiguration)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotificationConfigurationRequest", arg0)
}

func (_m *MockS3API) GetBucketNotificationRequest(_param0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) {
	ret := _m.ctrl.Call(_m, "GetBucketNotificationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.NotificationConfigurationDeprecated)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketNotificationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotificationRequest", arg0)
}

func (_m *MockS3API) GetBucketPolicy(_param0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketPolicy", _param0)
	ret0, _ := ret[0].(*s3.GetBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketPolicy(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketPolicy", arg0)
}

func (_m *MockS3API) GetBucketPolicyRequest(_param0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketPolicyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketPolicyOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketPolicyRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketPolicyRequest", arg0)
}

func (_m *MockS3API) GetBucketReplication(_param0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketReplication", _param0)
	ret0, _ := ret[0].(*s3.GetBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketReplication(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketReplication", arg0)
}

func (_m *MockS3API) GetBucketReplicationRequest(_param0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketReplicationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketReplicationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketReplicationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketReplicationRequest", arg0)
}

func (_m *MockS3API) GetBucketRequestPayment(_param0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketRequestPayment", _param0)
	ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketRequestPayment(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketRequestPayment", arg0)
}

func (_m *MockS3API) GetBucketRequestPaymentRequest(_param0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketRequestPaymentRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketRequestPaymentOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketRequestPaymentRequest", arg0)
}

func (_m *MockS3API) GetBucketTagging(_param0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketTagging", _param0)
	ret0, _ := ret[0].(*s3.GetBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketTagging(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketTagging", arg0)
}

func (_m *MockS3API) GetBucketTaggingRequest(_param0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketTaggingRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketTaggingOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketTaggingRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketTaggingRequest", arg0)
}

func (_m *MockS3API) GetBucketVersioning(_param0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketVersioning", _param0)
	ret0, _ := ret[0].(*s3.GetBucketVersioningOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketVersioning(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketVersioning", arg0)
}

func (_m *MockS3API) GetBucketVersioningRequest(_param0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketVersioningRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketVersioningOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketVersioningRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketVersioningRequest", arg0)
}

func (_m *MockS3API) GetBucketWebsite(_param0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) {
	ret := _m.ctrl.Call(_m, "GetBucketWebsite", _param0)
	ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketWebsite(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketWebsite", arg0)
}

func (_m *MockS3API) GetBucketWebsiteRequest(_param0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) {
	ret := _m.ctrl.Call(_m, "GetBucketWebsiteRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketWebsiteOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketWebsiteRequest", arg0)
}

func (_m *MockS3API) GetObject(_param0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
	ret := _m.ctrl.Call(_m, "GetObject", _param0)
	ret0, _ := ret[0].(*s3.GetObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetObject(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObject", arg0)
}

func (_m *MockS3API) GetObjectAcl(_param0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
	ret := _m.ctrl.Call(_m, "GetObjectAcl", _param0)
	ret0, _ := ret[0].(*s3.GetObjectAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetObjectAcl(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectAcl", arg0)
}

func (_m *MockS3API) GetObjectAclRequest(_param0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) {
	ret := _m.ctrl.Call(_m, "GetObjectAclRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectAclOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetObjectAclRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectAclRequest", arg0)
}

func (_m *MockS3API) GetObjectRequest(_param0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
	ret := _m.ctrl.Call(_m, "GetObjectRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetObjectRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectRequest", arg0)
}

func (_m *MockS3API) GetObjectTorrent(_param0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) {
	ret := _m.ctrl.Call(_m, "GetObjectTorrent", _param0)
	ret0, _ := ret[0].(*s3.GetObjectTorrentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetObjectTorrent(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectTorrent", arg0)
}

func (_m *MockS3API) GetObjectTorrentRequest(_param0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) {
	ret := _m.ctrl.Call(_m, "GetObjectTorrentRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectTorrentOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) GetObjectTorrentRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectTorrentRequest", arg0)
}

func (_m *MockS3API) HeadBucket(_param0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
	ret := _m.ctrl.Call(_m, "HeadBucket", _param0)
	ret0, _ := ret[0].(*s3.HeadBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) HeadBucket(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadBucket", arg0)
}

func (_m *MockS3API) HeadBucketRequest(_param0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) {
	ret := _m.ctrl.Call(_m, "HeadBucketRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.HeadBucketOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) HeadBucketRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadBucketRequest", arg0)
}

func (_m *MockS3API) HeadObject(_param0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
	ret := _m.ctrl.Call(_m, "HeadObject", _param0)
	ret0, _ := ret[0].(*s3.HeadObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) HeadObject(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadObject", arg0)
}

func (_m *MockS3API) HeadObjectRequest(_param0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) {
	ret := _m.ctrl.Call(_m, "HeadObjectRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.HeadObjectOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) HeadObjectRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadObjectRequest", arg0)
}

func (_m *MockS3API) ListBuckets(_param0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) {
	ret := _m.ctrl.Call(_m, "ListBuckets", _param0)
	ret0, _ := ret[0].(*s3.ListBucketsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListBuckets", arg0)
}

func (_m *MockS3API) ListBucketsRequest(_param0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) {
	ret := _m.ctrl.Call(_m, "ListBucketsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListBucketsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListBucketsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListBucketsRequest", arg0)
}

func (_m *MockS3API) ListMultipartUploads(_param0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) {
	ret := _m.ctrl.Call(_m, "ListMultipartUploads", _param0)
	ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListMultipartUploads(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListMultipartUploads", arg0)
}

func (_m *MockS3API) ListMultipartUploadsPages(_param0 *s3.ListMultipartUploadsInput, _param1 func(*s3.ListMultipartUploadsOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListMultipartUploadsPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockS3APIRecorder) ListMultipartUploadsPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListMultipartUploadsPages", arg0, arg1)
}

func (_m *MockS3API) ListMultipartUploadsRequest(_param0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) {
	ret := _m.ctrl.Call(_m, "ListMultipartUploadsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListMultipartUploadsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListMultipartUploadsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListMultipartUploadsRequest", arg0)
}

func (_m *MockS3API) ListObjectVersions(_param0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
	ret := _m.ctrl.Call(_m, "ListObjectVersions", _param0)
	ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListObjectVersions(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectVersions", arg0)
}

func (_m *MockS3API) ListObjectVersionsPages(_param0 *s3.ListObjectVersionsInput, _param1 func(*s3.ListObjectVersionsOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListObjectVersionsPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockS3APIRecorder) ListObjectVersionsPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectVersionsPages", arg0, arg1)
}

func (_m *MockS3API) ListObjectVersionsRequest(_param0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) {
	ret := _m.ctrl.Call(_m, "ListObjectVersionsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListObjectVersionsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListObjectVersionsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectVersionsRequest", arg0)
}

func (_m *MockS3API) ListObjects(_param0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
	ret := _m.ctrl.Call(_m, "ListObjects", _param0)
	ret0, _ := ret[0].(*s3.ListObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListObjects(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjects", arg0)
}

func (_m *MockS3API) ListObjectsPages(_param0 *s3.ListObjectsInput, _param1 func(*s3.ListObjectsOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListObjectsPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockS3APIRecorder) ListObjectsPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsPages", arg0, arg1)
}

func (_m *MockS3API) ListObjectsRequest(_param0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) {
	ret := _m.ctrl.Call(_m, "ListObjectsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListObjectsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListObjectsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsRequest", arg0)
}

func (_m *MockS3API) ListObjectsV2(_param0 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
	ret := _m.ctrl.Call(_m, "ListObjectsV2", _param0)
	ret0, _ := ret[0].(*s3.ListObjectsV2Output)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListObjectsV2(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsV2", arg0)
}

func (_m *MockS3API) ListObjectsV2Pages(_param0 *s3.ListObjectsV2Input, _param1 func(*s3.ListObjectsV2Output, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListObjectsV2Pages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockS3APIRecorder) ListObjectsV2Pages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsV2Pages", arg0, arg1)
}

func (_m *MockS3API) ListObjectsV2Request(_param0 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) {
	ret := _m.ctrl.Call(_m, "ListObjectsV2Request", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListObjectsV2Output)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListObjectsV2Request(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsV2Request", arg0)
}

func (_m *MockS3API) ListParts(_param0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) {
	ret := _m.ctrl.Call(_m, "ListParts", _param0)
	ret0, _ := ret[0].(*s3.ListPartsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListParts(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListParts", arg0)
}

func (_m *MockS3API) ListPartsPages(_param0 *s3.ListPartsInput, _param1 func(*s3.ListPartsOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListPartsPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockS3APIRecorder) ListPartsPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListPartsPages", arg0, arg1)
}

func (_m *MockS3API) ListPartsRequest(_param0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) {
	ret := _m.ctrl.Call(_m, "ListPartsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListPartsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) ListPartsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListPartsRequest", arg0)
}

func (_m *MockS3API) PutBucketAccelerateConfiguration(_param0 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketAccelerateConfiguration", _param0)
	ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketAccelerateConfiguration", arg0)
}

func (_m *MockS3API) PutBucketAccelerateConfigurationRequest(_param0 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketAccelerateConfigurationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketAccelerateConfigurationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketAccelerateConfigurationRequest", arg0)
}

func (_m *MockS3API) PutBucketAcl(_param0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketAcl", _param0)
	ret0, _ := ret[0].(*s3.PutBucketAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketAcl(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketAcl", arg0)
}

func (_m *MockS3API) PutBucketAclRequest(_param0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketAclRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketAclOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketAclRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketAclRequest", arg0)
}

func (_m *MockS3API) PutBucketCors(_param0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketCors", _param0)
	ret0, _ := ret[0].(*s3.PutBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketCors(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketCors", arg0)
}

func (_m *MockS3API) PutBucketCorsRequest(_param0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketCorsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketCorsOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketCorsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketCorsRequest", arg0)
}

func (_m *MockS3API) PutBucketLifecycle(_param0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketLifecycle", _param0)
	ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketLifecycle(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycle", arg0)
}

func (_m *MockS3API) PutBucketLifecycleConfiguration(_param0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketLifecycleConfiguration", _param0)
	ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycleConfiguration", arg0)
}

func (_m *MockS3API) PutBucketLifecycleConfigurationRequest(_param0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketLifecycleConfigurationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketLifecycleConfigurationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycleConfigurationRequest", arg0)
}

func (_m *MockS3API) PutBucketLifecycleRequest(_param0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketLifecycleRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketLifecycleOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycleRequest", arg0)
}

func (_m *MockS3API) PutBucketLogging(_param0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketLogging", _param0)
	ret0, _ := ret[0].(*s3.PutBucketLoggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketLogging(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLogging", arg0)
}

func (_m *MockS3API) PutBucketLoggingRequest(_param0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketLoggingRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketLoggingOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketLoggingRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLoggingRequest", arg0)
}

func (_m *MockS3API) PutBucketNotification(_param0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketNotification", _param0)
	ret0, _ := ret[0].(*s3.PutBucketNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketNotification(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotification", arg0)
}

func (_m *MockS3API) PutBucketNotificationConfiguration(_param0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketNotificationConfiguration", _param0)
	ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotificationConfiguration", arg0)
}

func (_m *MockS3API) PutBucketNotificationConfigurationRequest(_param0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketNotificationConfigurationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketNotificationConfigurationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotificationConfigurationRequest", arg0)
}

func (_m *MockS3API) PutBucketNotificationRequest(_param0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketNotificationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketNotificationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketNotificationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotificationRequest", arg0)
}

func (_m *MockS3API) PutBucketPolicy(_param0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketPolicy", _param0)
	ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketPolicy(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketPolicy", arg0)
}

func (_m *MockS3API) PutBucketPolicyRequest(_param0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketPolicyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketPolicyOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketPolicyRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketPolicyRequest", arg0)
}

func (_m *MockS3API) PutBucketReplication(_param0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketReplication", _param0)
	ret0, _ := ret[0].(*s3.PutBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketReplication(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketReplication", arg0)
}

func (_m *MockS3API) PutBucketReplicationRequest(_param0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketReplicationRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketReplicationOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketReplicationRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketReplicationRequest", arg0)
}

func (_m *MockS3API) PutBucketRequestPayment(_param0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketRequestPayment", _param0)
	ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketRequestPayment(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketRequestPayment", arg0)
}

func (_m *MockS3API) PutBucketRequestPaymentRequest(_param0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketRequestPaymentRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketRequestPaymentOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketRequestPaymentRequest", arg0)
}

func (_m *MockS3API) PutBucketTagging(_param0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketTagging", _param0)
	ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketTagging(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketTagging", arg0)
}

func (_m *MockS3API) PutBucketTaggingRequest(_param0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketTaggingRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketTaggingOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketTaggingRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketTaggingRequest", arg0)
}

func (_m *MockS3API) PutBucketVersioning(_param0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketVersioning", _param0)
	ret0, _ := ret[0].(*s3.PutBucketVersioningOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketVersioning(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketVersioning", arg0)
}

func (_m *MockS3API) PutBucketVersioningRequest(_param0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketVersioningRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketVersioningOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketVersioningRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketVersioningRequest", arg0)
}

func (_m *MockS3API) PutBucketWebsite(_param0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) {
	ret := _m.ctrl.Call(_m, "PutBucketWebsite", _param0)
	ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketWebsite(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketWebsite", arg0)
}

func (_m *MockS3API) PutBucketWebsiteRequest(_param0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) {
	ret := _m.ctrl.Call(_m, "PutBucketWebsiteRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketWebsiteOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketWebsiteRequest", arg0)
}

func (_m *MockS3API) PutObject(_param0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) {
	ret := _m.ctrl.Call(_m, "PutObject", _param0)
	ret0, _ := ret[0].(*s3.PutObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutObject(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObject", arg0)
}

func (_m *MockS3API) PutObjectAcl(_param0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) {
	ret := _m.ctrl.Call(_m, "PutObjectAcl", _param0)
	ret0, _ := ret[0].(*s3.PutObjectAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutObjectAcl(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObjectAcl", arg0)
}

func (_m *MockS3API) PutObjectAclRequest(_param0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) {
	ret := _m.ctrl.Call(_m, "PutObjectAclRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectAclOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutObjectAclRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObjectAclRequest", arg0)
}

func (_m *MockS3API) PutObjectRequest(_param0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) {
	ret := _m.ctrl.Call(_m, "PutObjectRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) PutObjectRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObjectRequest", arg0)
}

func (_m *MockS3API) RestoreObject(_param0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) {
	ret := _m.ctrl.Call(_m, "RestoreObject", _param0)
	ret0, _ := ret[0].(*s3.RestoreObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) RestoreObject(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RestoreObject", arg0)
}

func (_m *MockS3API) RestoreObjectRequest(_param0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) {
	ret := _m.ctrl.Call(_m, "RestoreObjectRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.RestoreObjectOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) RestoreObjectRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RestoreObjectRequest", arg0)
}

func (_m *MockS3API) UploadPart(_param0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
	ret := _m.ctrl.Call(_m, "UploadPart", _param0)
	ret0, _ := ret[0].(*s3.UploadPartOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) UploadPart(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPart", arg0)
}

func (_m *MockS3API) UploadPartCopy(_param0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) {
	ret := _m.ctrl.Call(_m, "UploadPartCopy", _param0)
	ret0, _ := ret[0].(*s3.UploadPartCopyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) UploadPartCopy(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPartCopy", arg0)
}

func (_m *MockS3API) UploadPartCopyRequest(_param0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) {
	ret := _m.ctrl.Call(_m, "UploadPartCopyRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.UploadPartCopyOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) UploadPartCopyRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPartCopyRequest", arg0)
}

func (_m *MockS3API) UploadPartRequest(_param0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) {
	ret := _m.ctrl.Call(_m, "UploadPartRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.UploadPartOutput)
	return ret0, ret1
}

func (_mr *_MockS3APIRecorder) UploadPartRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPartRequest", arg0)
}