mock_s3.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/44smkn/s3select/pkg/aws/services (interfaces: S3)

// Package mock_services is a generated GoMock package.
package mock_services

import (
	context "context"
	reflect "reflect"

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

// MockS3 is a mock of S3 interface.
type MockS3 struct {
	ctrl     *gomock.Controller
	recorder *MockS3MockRecorder
}

// MockS3MockRecorder is the mock recorder for MockS3.
type MockS3MockRecorder struct {
	mock *MockS3
}

// NewMockS3 creates a new mock instance.
func NewMockS3(ctrl *gomock.Controller) *MockS3 {
	mock := &MockS3{ctrl: ctrl}
	mock.recorder = &MockS3MockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockS3) EXPECT() *MockS3MockRecorder {
	return m.recorder
}

// AbortMultipartUpload mocks base method.
func (m *MockS3) AbortMultipartUpload(arg0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AbortMultipartUpload", arg0)
	ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AbortMultipartUpload indicates an expected call of AbortMultipartUpload.
func (mr *MockS3MockRecorder) AbortMultipartUpload(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUpload", reflect.TypeOf((*MockS3)(nil).AbortMultipartUpload), arg0)
}

// AbortMultipartUploadRequest mocks base method.
func (m *MockS3) AbortMultipartUploadRequest(arg0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AbortMultipartUploadRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.AbortMultipartUploadOutput)
	return ret0, ret1
}

// AbortMultipartUploadRequest indicates an expected call of AbortMultipartUploadRequest.
func (mr *MockS3MockRecorder) AbortMultipartUploadRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUploadRequest", reflect.TypeOf((*MockS3)(nil).AbortMultipartUploadRequest), arg0)
}

// AbortMultipartUploadWithContext mocks base method.
func (m *MockS3) AbortMultipartUploadWithContext(arg0 context.Context, arg1 *s3.AbortMultipartUploadInput, arg2 ...request.Option) (*s3.AbortMultipartUploadOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AbortMultipartUploadWithContext", varargs...)
	ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AbortMultipartUploadWithContext indicates an expected call of AbortMultipartUploadWithContext.
func (mr *MockS3MockRecorder) AbortMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUploadWithContext", reflect.TypeOf((*MockS3)(nil).AbortMultipartUploadWithContext), varargs...)
}

// CompleteMultipartUpload mocks base method.
func (m *MockS3) CompleteMultipartUpload(arg0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteMultipartUpload", arg0)
	ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteMultipartUpload indicates an expected call of CompleteMultipartUpload.
func (mr *MockS3MockRecorder) CompleteMultipartUpload(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUpload", reflect.TypeOf((*MockS3)(nil).CompleteMultipartUpload), arg0)
}

// CompleteMultipartUploadRequest mocks base method.
func (m *MockS3) CompleteMultipartUploadRequest(arg0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteMultipartUploadRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CompleteMultipartUploadOutput)
	return ret0, ret1
}

// CompleteMultipartUploadRequest indicates an expected call of CompleteMultipartUploadRequest.
func (mr *MockS3MockRecorder) CompleteMultipartUploadRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUploadRequest", reflect.TypeOf((*MockS3)(nil).CompleteMultipartUploadRequest), arg0)
}

// CompleteMultipartUploadWithContext mocks base method.
func (m *MockS3) CompleteMultipartUploadWithContext(arg0 context.Context, arg1 *s3.CompleteMultipartUploadInput, arg2 ...request.Option) (*s3.CompleteMultipartUploadOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CompleteMultipartUploadWithContext", varargs...)
	ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteMultipartUploadWithContext indicates an expected call of CompleteMultipartUploadWithContext.
func (mr *MockS3MockRecorder) CompleteMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUploadWithContext", reflect.TypeOf((*MockS3)(nil).CompleteMultipartUploadWithContext), varargs...)
}

// CopyObject mocks base method.
func (m *MockS3) CopyObject(arg0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyObject", arg0)
	ret0, _ := ret[0].(*s3.CopyObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyObject indicates an expected call of CopyObject.
func (mr *MockS3MockRecorder) CopyObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObject", reflect.TypeOf((*MockS3)(nil).CopyObject), arg0)
}

// CopyObjectRequest mocks base method.
func (m *MockS3) CopyObjectRequest(arg0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyObjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CopyObjectOutput)
	return ret0, ret1
}

// CopyObjectRequest indicates an expected call of CopyObjectRequest.
func (mr *MockS3MockRecorder) CopyObjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectRequest", reflect.TypeOf((*MockS3)(nil).CopyObjectRequest), arg0)
}

// CopyObjectWithContext mocks base method.
func (m *MockS3) CopyObjectWithContext(arg0 context.Context, arg1 *s3.CopyObjectInput, arg2 ...request.Option) (*s3.CopyObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CopyObjectWithContext", varargs...)
	ret0, _ := ret[0].(*s3.CopyObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyObjectWithContext indicates an expected call of CopyObjectWithContext.
func (mr *MockS3MockRecorder) CopyObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectWithContext", reflect.TypeOf((*MockS3)(nil).CopyObjectWithContext), varargs...)
}

// CreateBucket mocks base method.
func (m *MockS3) CreateBucket(arg0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBucket", arg0)
	ret0, _ := ret[0].(*s3.CreateBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBucket indicates an expected call of CreateBucket.
func (mr *MockS3MockRecorder) CreateBucket(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockS3)(nil).CreateBucket), arg0)
}

// CreateBucketRequest mocks base method.
func (m *MockS3) CreateBucketRequest(arg0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBucketRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CreateBucketOutput)
	return ret0, ret1
}

// CreateBucketRequest indicates an expected call of CreateBucketRequest.
func (mr *MockS3MockRecorder) CreateBucketRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucketRequest", reflect.TypeOf((*MockS3)(nil).CreateBucketRequest), arg0)
}

// CreateBucketWithContext mocks base method.
func (m *MockS3) CreateBucketWithContext(arg0 context.Context, arg1 *s3.CreateBucketInput, arg2 ...request.Option) (*s3.CreateBucketOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBucketWithContext", varargs...)
	ret0, _ := ret[0].(*s3.CreateBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBucketWithContext indicates an expected call of CreateBucketWithContext.
func (mr *MockS3MockRecorder) CreateBucketWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucketWithContext", reflect.TypeOf((*MockS3)(nil).CreateBucketWithContext), varargs...)
}

// CreateMultipartUpload mocks base method.
func (m *MockS3) CreateMultipartUpload(arg0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMultipartUpload", arg0)
	ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateMultipartUpload indicates an expected call of CreateMultipartUpload.
func (mr *MockS3MockRecorder) CreateMultipartUpload(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUpload", reflect.TypeOf((*MockS3)(nil).CreateMultipartUpload), arg0)
}

// CreateMultipartUploadRequest mocks base method.
func (m *MockS3) CreateMultipartUploadRequest(arg0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMultipartUploadRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.CreateMultipartUploadOutput)
	return ret0, ret1
}

// CreateMultipartUploadRequest indicates an expected call of CreateMultipartUploadRequest.
func (mr *MockS3MockRecorder) CreateMultipartUploadRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUploadRequest", reflect.TypeOf((*MockS3)(nil).CreateMultipartUploadRequest), arg0)
}

// CreateMultipartUploadWithContext mocks base method.
func (m *MockS3) CreateMultipartUploadWithContext(arg0 context.Context, arg1 *s3.CreateMultipartUploadInput, arg2 ...request.Option) (*s3.CreateMultipartUploadOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMultipartUploadWithContext", varargs...)
	ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateMultipartUploadWithContext indicates an expected call of CreateMultipartUploadWithContext.
func (mr *MockS3MockRecorder) CreateMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUploadWithContext", reflect.TypeOf((*MockS3)(nil).CreateMultipartUploadWithContext), varargs...)
}

// DeleteBucket mocks base method.
func (m *MockS3) DeleteBucket(arg0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucket", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucket indicates an expected call of DeleteBucket.
func (mr *MockS3MockRecorder) DeleteBucket(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockS3)(nil).DeleteBucket), arg0)
}

// DeleteBucketAnalyticsConfiguration mocks base method.
func (m *MockS3) DeleteBucketAnalyticsConfiguration(arg0 *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfiguration", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketAnalyticsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketAnalyticsConfiguration indicates an expected call of DeleteBucketAnalyticsConfiguration.
func (mr *MockS3MockRecorder) DeleteBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3)(nil).DeleteBucketAnalyticsConfiguration), arg0)
}

// DeleteBucketAnalyticsConfigurationRequest mocks base method.
func (m *MockS3) DeleteBucketAnalyticsConfigurationRequest(arg0 *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketAnalyticsConfigurationOutput)
	return ret0, ret1
}

// DeleteBucketAnalyticsConfigurationRequest indicates an expected call of DeleteBucketAnalyticsConfigurationRequest.
func (mr *MockS3MockRecorder) DeleteBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketAnalyticsConfigurationRequest), arg0)
}

// DeleteBucketAnalyticsConfigurationWithContext mocks base method.
func (m *MockS3) DeleteBucketAnalyticsConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketAnalyticsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketAnalyticsConfigurationWithContext indicates an expected call of DeleteBucketAnalyticsConfigurationWithContext.
func (mr *MockS3MockRecorder) DeleteBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketAnalyticsConfigurationWithContext), varargs...)
}

// DeleteBucketCors mocks base method.
func (m *MockS3) DeleteBucketCors(arg0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketCors", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketCors indicates an expected call of DeleteBucketCors.
func (mr *MockS3MockRecorder) DeleteBucketCors(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCors", reflect.TypeOf((*MockS3)(nil).DeleteBucketCors), arg0)
}

// DeleteBucketCorsRequest mocks base method.
func (m *MockS3) DeleteBucketCorsRequest(arg0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketCorsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketCorsOutput)
	return ret0, ret1
}

// DeleteBucketCorsRequest indicates an expected call of DeleteBucketCorsRequest.
func (mr *MockS3MockRecorder) DeleteBucketCorsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCorsRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketCorsRequest), arg0)
}

// DeleteBucketCorsWithContext mocks base method.
func (m *MockS3) DeleteBucketCorsWithContext(arg0 context.Context, arg1 *s3.DeleteBucketCorsInput, arg2 ...request.Option) (*s3.DeleteBucketCorsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketCorsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketCorsWithContext indicates an expected call of DeleteBucketCorsWithContext.
func (mr *MockS3MockRecorder) DeleteBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCorsWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketCorsWithContext), varargs...)
}

// DeleteBucketEncryption mocks base method.
func (m *MockS3) DeleteBucketEncryption(arg0 *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketEncryption", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketEncryption indicates an expected call of DeleteBucketEncryption.
func (mr *MockS3MockRecorder) DeleteBucketEncryption(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryption", reflect.TypeOf((*MockS3)(nil).DeleteBucketEncryption), arg0)
}

// DeleteBucketEncryptionRequest mocks base method.
func (m *MockS3) DeleteBucketEncryptionRequest(arg0 *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketEncryptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketEncryptionOutput)
	return ret0, ret1
}

// DeleteBucketEncryptionRequest indicates an expected call of DeleteBucketEncryptionRequest.
func (mr *MockS3MockRecorder) DeleteBucketEncryptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryptionRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketEncryptionRequest), arg0)
}

// DeleteBucketEncryptionWithContext mocks base method.
func (m *MockS3) DeleteBucketEncryptionWithContext(arg0 context.Context, arg1 *s3.DeleteBucketEncryptionInput, arg2 ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketEncryptionWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketEncryptionWithContext indicates an expected call of DeleteBucketEncryptionWithContext.
func (mr *MockS3MockRecorder) DeleteBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryptionWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketEncryptionWithContext), varargs...)
}

// DeleteBucketIntelligentTieringConfiguration mocks base method.
func (m *MockS3) DeleteBucketIntelligentTieringConfiguration(arg0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketIntelligentTieringConfiguration", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketIntelligentTieringConfiguration indicates an expected call of DeleteBucketIntelligentTieringConfiguration.
func (mr *MockS3MockRecorder) DeleteBucketIntelligentTieringConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketIntelligentTieringConfiguration", reflect.TypeOf((*MockS3)(nil).DeleteBucketIntelligentTieringConfiguration), arg0)
}

// DeleteBucketIntelligentTieringConfigurationRequest mocks base method.
func (m *MockS3) DeleteBucketIntelligentTieringConfigurationRequest(arg0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketIntelligentTieringConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
	return ret0, ret1
}

// DeleteBucketIntelligentTieringConfigurationRequest indicates an expected call of DeleteBucketIntelligentTieringConfigurationRequest.
func (mr *MockS3MockRecorder) DeleteBucketIntelligentTieringConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketIntelligentTieringConfigurationRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketIntelligentTieringConfigurationRequest), arg0)
}

// DeleteBucketIntelligentTieringConfigurationWithContext mocks base method.
func (m *MockS3) DeleteBucketIntelligentTieringConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketIntelligentTieringConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketIntelligentTieringConfigurationWithContext indicates an expected call of DeleteBucketIntelligentTieringConfigurationWithContext.
func (mr *MockS3MockRecorder) DeleteBucketIntelligentTieringConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketIntelligentTieringConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketIntelligentTieringConfigurationWithContext), varargs...)
}

// DeleteBucketInventoryConfiguration mocks base method.
func (m *MockS3) DeleteBucketInventoryConfiguration(arg0 *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketInventoryConfiguration", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketInventoryConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketInventoryConfiguration indicates an expected call of DeleteBucketInventoryConfiguration.
func (mr *MockS3MockRecorder) DeleteBucketInventoryConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfiguration", reflect.TypeOf((*MockS3)(nil).DeleteBucketInventoryConfiguration), arg0)
}

// DeleteBucketInventoryConfigurationRequest mocks base method.
func (m *MockS3) DeleteBucketInventoryConfigurationRequest(arg0 *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketInventoryConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketInventoryConfigurationOutput)
	return ret0, ret1
}

// DeleteBucketInventoryConfigurationRequest indicates an expected call of DeleteBucketInventoryConfigurationRequest.
func (mr *MockS3MockRecorder) DeleteBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketInventoryConfigurationRequest), arg0)
}

// DeleteBucketInventoryConfigurationWithContext mocks base method.
func (m *MockS3) DeleteBucketInventoryConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketInventoryConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketInventoryConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketInventoryConfigurationWithContext indicates an expected call of DeleteBucketInventoryConfigurationWithContext.
func (mr *MockS3MockRecorder) DeleteBucketInventoryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketInventoryConfigurationWithContext), varargs...)
}

// DeleteBucketLifecycle mocks base method.
func (m *MockS3) DeleteBucketLifecycle(arg0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketLifecycle", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketLifecycle indicates an expected call of DeleteBucketLifecycle.
func (mr *MockS3MockRecorder) DeleteBucketLifecycle(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycle", reflect.TypeOf((*MockS3)(nil).DeleteBucketLifecycle), arg0)
}

// DeleteBucketLifecycleRequest mocks base method.
func (m *MockS3) DeleteBucketLifecycleRequest(arg0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketLifecycleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketLifecycleOutput)
	return ret0, ret1
}

// DeleteBucketLifecycleRequest indicates an expected call of DeleteBucketLifecycleRequest.
func (mr *MockS3MockRecorder) DeleteBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycleRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketLifecycleRequest), arg0)
}

// DeleteBucketLifecycleWithContext mocks base method.
func (m *MockS3) DeleteBucketLifecycleWithContext(arg0 context.Context, arg1 *s3.DeleteBucketLifecycleInput, arg2 ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketLifecycleWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketLifecycleWithContext indicates an expected call of DeleteBucketLifecycleWithContext.
func (mr *MockS3MockRecorder) DeleteBucketLifecycleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycleWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketLifecycleWithContext), varargs...)
}

// DeleteBucketMetricsConfiguration mocks base method.
func (m *MockS3) DeleteBucketMetricsConfiguration(arg0 *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketMetricsConfiguration", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketMetricsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketMetricsConfiguration indicates an expected call of DeleteBucketMetricsConfiguration.
func (mr *MockS3MockRecorder) DeleteBucketMetricsConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfiguration", reflect.TypeOf((*MockS3)(nil).DeleteBucketMetricsConfiguration), arg0)
}

// DeleteBucketMetricsConfigurationRequest mocks base method.
func (m *MockS3) DeleteBucketMetricsConfigurationRequest(arg0 *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketMetricsConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketMetricsConfigurationOutput)
	return ret0, ret1
}

// DeleteBucketMetricsConfigurationRequest indicates an expected call of DeleteBucketMetricsConfigurationRequest.
func (mr *MockS3MockRecorder) DeleteBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketMetricsConfigurationRequest), arg0)
}

// DeleteBucketMetricsConfigurationWithContext mocks base method.
func (m *MockS3) DeleteBucketMetricsConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketMetricsConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketMetricsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketMetricsConfigurationWithContext indicates an expected call of DeleteBucketMetricsConfigurationWithContext.
func (mr *MockS3MockRecorder) DeleteBucketMetricsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketMetricsConfigurationWithContext), varargs...)
}

// DeleteBucketOwnershipControls mocks base method.
func (m *MockS3) DeleteBucketOwnershipControls(arg0 *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketOwnershipControls", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketOwnershipControlsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketOwnershipControls indicates an expected call of DeleteBucketOwnershipControls.
func (mr *MockS3MockRecorder) DeleteBucketOwnershipControls(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketOwnershipControls", reflect.TypeOf((*MockS3)(nil).DeleteBucketOwnershipControls), arg0)
}

// DeleteBucketOwnershipControlsRequest mocks base method.
func (m *MockS3) DeleteBucketOwnershipControlsRequest(arg0 *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketOwnershipControlsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketOwnershipControlsOutput)
	return ret0, ret1
}

// DeleteBucketOwnershipControlsRequest indicates an expected call of DeleteBucketOwnershipControlsRequest.
func (mr *MockS3MockRecorder) DeleteBucketOwnershipControlsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketOwnershipControlsRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketOwnershipControlsRequest), arg0)
}

// DeleteBucketOwnershipControlsWithContext mocks base method.
func (m *MockS3) DeleteBucketOwnershipControlsWithContext(arg0 context.Context, arg1 *s3.DeleteBucketOwnershipControlsInput, arg2 ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketOwnershipControlsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketOwnershipControlsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketOwnershipControlsWithContext indicates an expected call of DeleteBucketOwnershipControlsWithContext.
func (mr *MockS3MockRecorder) DeleteBucketOwnershipControlsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketOwnershipControlsWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketOwnershipControlsWithContext), varargs...)
}

// DeleteBucketPolicy mocks base method.
func (m *MockS3) DeleteBucketPolicy(arg0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketPolicy", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketPolicy indicates an expected call of DeleteBucketPolicy.
func (mr *MockS3MockRecorder) DeleteBucketPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicy", reflect.TypeOf((*MockS3)(nil).DeleteBucketPolicy), arg0)
}

// DeleteBucketPolicyRequest mocks base method.
func (m *MockS3) DeleteBucketPolicyRequest(arg0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketPolicyOutput)
	return ret0, ret1
}

// DeleteBucketPolicyRequest indicates an expected call of DeleteBucketPolicyRequest.
func (mr *MockS3MockRecorder) DeleteBucketPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicyRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketPolicyRequest), arg0)
}

// DeleteBucketPolicyWithContext mocks base method.
func (m *MockS3) DeleteBucketPolicyWithContext(arg0 context.Context, arg1 *s3.DeleteBucketPolicyInput, arg2 ...request.Option) (*s3.DeleteBucketPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketPolicyWithContext indicates an expected call of DeleteBucketPolicyWithContext.
func (mr *MockS3MockRecorder) DeleteBucketPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicyWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketPolicyWithContext), varargs...)
}

// DeleteBucketReplication mocks base method.
func (m *MockS3) DeleteBucketReplication(arg0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketReplication", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketReplication indicates an expected call of DeleteBucketReplication.
func (mr *MockS3MockRecorder) DeleteBucketReplication(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplication", reflect.TypeOf((*MockS3)(nil).DeleteBucketReplication), arg0)
}

// DeleteBucketReplicationRequest mocks base method.
func (m *MockS3) DeleteBucketReplicationRequest(arg0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketReplicationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketReplicationOutput)
	return ret0, ret1
}

// DeleteBucketReplicationRequest indicates an expected call of DeleteBucketReplicationRequest.
func (mr *MockS3MockRecorder) DeleteBucketReplicationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplicationRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketReplicationRequest), arg0)
}

// DeleteBucketReplicationWithContext mocks base method.
func (m *MockS3) DeleteBucketReplicationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketReplicationInput, arg2 ...request.Option) (*s3.DeleteBucketReplicationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketReplicationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketReplicationWithContext indicates an expected call of DeleteBucketReplicationWithContext.
func (mr *MockS3MockRecorder) DeleteBucketReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplicationWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketReplicationWithContext), varargs...)
}

// DeleteBucketRequest mocks base method.
func (m *MockS3) DeleteBucketRequest(arg0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketOutput)
	return ret0, ret1
}

// DeleteBucketRequest indicates an expected call of DeleteBucketRequest.
func (mr *MockS3MockRecorder) DeleteBucketRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketRequest), arg0)
}

// DeleteBucketTagging mocks base method.
func (m *MockS3) DeleteBucketTagging(arg0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketTagging", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketTagging indicates an expected call of DeleteBucketTagging.
func (mr *MockS3MockRecorder) DeleteBucketTagging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTagging", reflect.TypeOf((*MockS3)(nil).DeleteBucketTagging), arg0)
}

// DeleteBucketTaggingRequest mocks base method.
func (m *MockS3) DeleteBucketTaggingRequest(arg0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketTaggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketTaggingOutput)
	return ret0, ret1
}

// DeleteBucketTaggingRequest indicates an expected call of DeleteBucketTaggingRequest.
func (mr *MockS3MockRecorder) DeleteBucketTaggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTaggingRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketTaggingRequest), arg0)
}

// DeleteBucketTaggingWithContext mocks base method.
func (m *MockS3) DeleteBucketTaggingWithContext(arg0 context.Context, arg1 *s3.DeleteBucketTaggingInput, arg2 ...request.Option) (*s3.DeleteBucketTaggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketTaggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketTaggingWithContext indicates an expected call of DeleteBucketTaggingWithContext.
func (mr *MockS3MockRecorder) DeleteBucketTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTaggingWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketTaggingWithContext), varargs...)
}

// DeleteBucketWebsite mocks base method.
func (m *MockS3) DeleteBucketWebsite(arg0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketWebsite", arg0)
	ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketWebsite indicates an expected call of DeleteBucketWebsite.
func (mr *MockS3MockRecorder) DeleteBucketWebsite(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsite", reflect.TypeOf((*MockS3)(nil).DeleteBucketWebsite), arg0)
}

// DeleteBucketWebsiteRequest mocks base method.
func (m *MockS3) DeleteBucketWebsiteRequest(arg0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucketWebsiteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteBucketWebsiteOutput)
	return ret0, ret1
}

// DeleteBucketWebsiteRequest indicates an expected call of DeleteBucketWebsiteRequest.
func (mr *MockS3MockRecorder) DeleteBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsiteRequest", reflect.TypeOf((*MockS3)(nil).DeleteBucketWebsiteRequest), arg0)
}

// DeleteBucketWebsiteWithContext mocks base method.
func (m *MockS3) DeleteBucketWebsiteWithContext(arg0 context.Context, arg1 *s3.DeleteBucketWebsiteInput, arg2 ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketWebsiteWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketWebsiteWithContext indicates an expected call of DeleteBucketWebsiteWithContext.
func (mr *MockS3MockRecorder) DeleteBucketWebsiteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsiteWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketWebsiteWithContext), varargs...)
}

// DeleteBucketWithContext mocks base method.
func (m *MockS3) DeleteBucketWithContext(arg0 context.Context, arg1 *s3.DeleteBucketInput, arg2 ...request.Option) (*s3.DeleteBucketOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBucketWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBucketWithContext indicates an expected call of DeleteBucketWithContext.
func (mr *MockS3MockRecorder) DeleteBucketWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWithContext", reflect.TypeOf((*MockS3)(nil).DeleteBucketWithContext), varargs...)
}

// DeleteObject mocks base method.
func (m *MockS3) DeleteObject(arg0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObject", arg0)
	ret0, _ := ret[0].(*s3.DeleteObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObject indicates an expected call of DeleteObject.
func (mr *MockS3MockRecorder) DeleteObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockS3)(nil).DeleteObject), arg0)
}

// DeleteObjectRequest mocks base method.
func (m *MockS3) DeleteObjectRequest(arg0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteObjectOutput)
	return ret0, ret1
}

// DeleteObjectRequest indicates an expected call of DeleteObjectRequest.
func (mr *MockS3MockRecorder) DeleteObjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectRequest", reflect.TypeOf((*MockS3)(nil).DeleteObjectRequest), arg0)
}

// DeleteObjectTagging mocks base method.
func (m *MockS3) DeleteObjectTagging(arg0 *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectTagging", arg0)
	ret0, _ := ret[0].(*s3.DeleteObjectTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectTagging indicates an expected call of DeleteObjectTagging.
func (mr *MockS3MockRecorder) DeleteObjectTagging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTagging", reflect.TypeOf((*MockS3)(nil).DeleteObjectTagging), arg0)
}

// DeleteObjectTaggingRequest mocks base method.
func (m *MockS3) DeleteObjectTaggingRequest(arg0 *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectTaggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteObjectTaggingOutput)
	return ret0, ret1
}

// DeleteObjectTaggingRequest indicates an expected call of DeleteObjectTaggingRequest.
func (mr *MockS3MockRecorder) DeleteObjectTaggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTaggingRequest", reflect.TypeOf((*MockS3)(nil).DeleteObjectTaggingRequest), arg0)
}

// DeleteObjectTaggingWithContext mocks base method.
func (m *MockS3) DeleteObjectTaggingWithContext(arg0 context.Context, arg1 *s3.DeleteObjectTaggingInput, arg2 ...request.Option) (*s3.DeleteObjectTaggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteObjectTaggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteObjectTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectTaggingWithContext indicates an expected call of DeleteObjectTaggingWithContext.
func (mr *MockS3MockRecorder) DeleteObjectTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTaggingWithContext", reflect.TypeOf((*MockS3)(nil).DeleteObjectTaggingWithContext), varargs...)
}

// DeleteObjectWithContext mocks base method.
func (m *MockS3) DeleteObjectWithContext(arg0 context.Context, arg1 *s3.DeleteObjectInput, arg2 ...request.Option) (*s3.DeleteObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteObjectWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectWithContext indicates an expected call of DeleteObjectWithContext.
func (mr *MockS3MockRecorder) DeleteObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectWithContext", reflect.TypeOf((*MockS3)(nil).DeleteObjectWithContext), varargs...)
}

// DeleteObjects mocks base method.
func (m *MockS3) DeleteObjects(arg0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjects", arg0)
	ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjects indicates an expected call of DeleteObjects.
func (mr *MockS3MockRecorder) DeleteObjects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjects", reflect.TypeOf((*MockS3)(nil).DeleteObjects), arg0)
}

// DeleteObjectsRequest mocks base method.
func (m *MockS3) DeleteObjectsRequest(arg0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeleteObjectsOutput)
	return ret0, ret1
}

// DeleteObjectsRequest indicates an expected call of DeleteObjectsRequest.
func (mr *MockS3MockRecorder) DeleteObjectsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectsRequest", reflect.TypeOf((*MockS3)(nil).DeleteObjectsRequest), arg0)
}

// DeleteObjectsWithContext mocks base method.
func (m *MockS3) DeleteObjectsWithContext(arg0 context.Context, arg1 *s3.DeleteObjectsInput, arg2 ...request.Option) (*s3.DeleteObjectsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteObjectsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectsWithContext indicates an expected call of DeleteObjectsWithContext.
func (mr *MockS3MockRecorder) DeleteObjectsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectsWithContext", reflect.TypeOf((*MockS3)(nil).DeleteObjectsWithContext), varargs...)
}

// DeletePublicAccessBlock mocks base method.
func (m *MockS3) DeletePublicAccessBlock(arg0 *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePublicAccessBlock", arg0)
	ret0, _ := ret[0].(*s3.DeletePublicAccessBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePublicAccessBlock indicates an expected call of DeletePublicAccessBlock.
func (mr *MockS3MockRecorder) DeletePublicAccessBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicAccessBlock", reflect.TypeOf((*MockS3)(nil).DeletePublicAccessBlock), arg0)
}

// DeletePublicAccessBlockRequest mocks base method.
func (m *MockS3) DeletePublicAccessBlockRequest(arg0 *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePublicAccessBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.DeletePublicAccessBlockOutput)
	return ret0, ret1
}

// DeletePublicAccessBlockRequest indicates an expected call of DeletePublicAccessBlockRequest.
func (mr *MockS3MockRecorder) DeletePublicAccessBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicAccessBlockRequest", reflect.TypeOf((*MockS3)(nil).DeletePublicAccessBlockRequest), arg0)
}

// DeletePublicAccessBlockWithContext mocks base method.
func (m *MockS3) DeletePublicAccessBlockWithContext(arg0 context.Context, arg1 *s3.DeletePublicAccessBlockInput, arg2 ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePublicAccessBlockWithContext", varargs...)
	ret0, _ := ret[0].(*s3.DeletePublicAccessBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePublicAccessBlockWithContext indicates an expected call of DeletePublicAccessBlockWithContext.
func (mr *MockS3MockRecorder) DeletePublicAccessBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicAccessBlockWithContext", reflect.TypeOf((*MockS3)(nil).DeletePublicAccessBlockWithContext), varargs...)
}

// GetBucketAccelerateConfiguration mocks base method.
func (m *MockS3) GetBucketAccelerateConfiguration(arg0 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketAccelerateConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketAccelerateConfiguration indicates an expected call of GetBucketAccelerateConfiguration.
func (mr *MockS3MockRecorder) GetBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketAccelerateConfiguration), arg0)
}

// GetBucketAccelerateConfigurationRequest mocks base method.
func (m *MockS3) GetBucketAccelerateConfigurationRequest(arg0 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketAccelerateConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketAccelerateConfigurationOutput)
	return ret0, ret1
}

// GetBucketAccelerateConfigurationRequest indicates an expected call of GetBucketAccelerateConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketAccelerateConfigurationRequest), arg0)
}

// GetBucketAccelerateConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketAccelerateConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketAccelerateConfigurationInput, arg2 ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketAccelerateConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketAccelerateConfigurationWithContext indicates an expected call of GetBucketAccelerateConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketAccelerateConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketAccelerateConfigurationWithContext), varargs...)
}

// GetBucketAcl mocks base method.
func (m *MockS3) GetBucketAcl(arg0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketAcl", arg0)
	ret0, _ := ret[0].(*s3.GetBucketAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketAcl indicates an expected call of GetBucketAcl.
func (mr *MockS3MockRecorder) GetBucketAcl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAcl", reflect.TypeOf((*MockS3)(nil).GetBucketAcl), arg0)
}

// GetBucketAclRequest mocks base method.
func (m *MockS3) GetBucketAclRequest(arg0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketAclRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketAclOutput)
	return ret0, ret1
}

// GetBucketAclRequest indicates an expected call of GetBucketAclRequest.
func (mr *MockS3MockRecorder) GetBucketAclRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAclRequest", reflect.TypeOf((*MockS3)(nil).GetBucketAclRequest), arg0)
}

// GetBucketAclWithContext mocks base method.
func (m *MockS3) GetBucketAclWithContext(arg0 context.Context, arg1 *s3.GetBucketAclInput, arg2 ...request.Option) (*s3.GetBucketAclOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketAclWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketAclWithContext indicates an expected call of GetBucketAclWithContext.
func (mr *MockS3MockRecorder) GetBucketAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAclWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketAclWithContext), varargs...)
}

// GetBucketAnalyticsConfiguration mocks base method.
func (m *MockS3) GetBucketAnalyticsConfiguration(arg0 *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketAnalyticsConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetBucketAnalyticsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketAnalyticsConfiguration indicates an expected call of GetBucketAnalyticsConfiguration.
func (mr *MockS3MockRecorder) GetBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketAnalyticsConfiguration), arg0)
}

// GetBucketAnalyticsConfigurationRequest mocks base method.
func (m *MockS3) GetBucketAnalyticsConfigurationRequest(arg0 *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketAnalyticsConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketAnalyticsConfigurationOutput)
	return ret0, ret1
}

// GetBucketAnalyticsConfigurationRequest indicates an expected call of GetBucketAnalyticsConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketAnalyticsConfigurationRequest), arg0)
}

// GetBucketAnalyticsConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketAnalyticsConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketAnalyticsConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketAnalyticsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketAnalyticsConfigurationWithContext indicates an expected call of GetBucketAnalyticsConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketAnalyticsConfigurationWithContext), varargs...)
}

// GetBucketCors mocks base method.
func (m *MockS3) GetBucketCors(arg0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketCors", arg0)
	ret0, _ := ret[0].(*s3.GetBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketCors indicates an expected call of GetBucketCors.
func (mr *MockS3MockRecorder) GetBucketCors(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCors", reflect.TypeOf((*MockS3)(nil).GetBucketCors), arg0)
}

// GetBucketCorsRequest mocks base method.
func (m *MockS3) GetBucketCorsRequest(arg0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketCorsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketCorsOutput)
	return ret0, ret1
}

// GetBucketCorsRequest indicates an expected call of GetBucketCorsRequest.
func (mr *MockS3MockRecorder) GetBucketCorsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCorsRequest", reflect.TypeOf((*MockS3)(nil).GetBucketCorsRequest), arg0)
}

// GetBucketCorsWithContext mocks base method.
func (m *MockS3) GetBucketCorsWithContext(arg0 context.Context, arg1 *s3.GetBucketCorsInput, arg2 ...request.Option) (*s3.GetBucketCorsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketCorsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketCorsWithContext indicates an expected call of GetBucketCorsWithContext.
func (mr *MockS3MockRecorder) GetBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCorsWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketCorsWithContext), varargs...)
}

// GetBucketEncryption mocks base method.
func (m *MockS3) GetBucketEncryption(arg0 *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketEncryption", arg0)
	ret0, _ := ret[0].(*s3.GetBucketEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketEncryption indicates an expected call of GetBucketEncryption.
func (mr *MockS3MockRecorder) GetBucketEncryption(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryption", reflect.TypeOf((*MockS3)(nil).GetBucketEncryption), arg0)
}

// GetBucketEncryptionRequest mocks base method.
func (m *MockS3) GetBucketEncryptionRequest(arg0 *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketEncryptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketEncryptionOutput)
	return ret0, ret1
}

// GetBucketEncryptionRequest indicates an expected call of GetBucketEncryptionRequest.
func (mr *MockS3MockRecorder) GetBucketEncryptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryptionRequest", reflect.TypeOf((*MockS3)(nil).GetBucketEncryptionRequest), arg0)
}

// GetBucketEncryptionWithContext mocks base method.
func (m *MockS3) GetBucketEncryptionWithContext(arg0 context.Context, arg1 *s3.GetBucketEncryptionInput, arg2 ...request.Option) (*s3.GetBucketEncryptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketEncryptionWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketEncryptionWithContext indicates an expected call of GetBucketEncryptionWithContext.
func (mr *MockS3MockRecorder) GetBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryptionWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketEncryptionWithContext), varargs...)
}

// GetBucketIntelligentTieringConfiguration mocks base method.
func (m *MockS3) GetBucketIntelligentTieringConfiguration(arg0 *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketIntelligentTieringConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetBucketIntelligentTieringConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketIntelligentTieringConfiguration indicates an expected call of GetBucketIntelligentTieringConfiguration.
func (mr *MockS3MockRecorder) GetBucketIntelligentTieringConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketIntelligentTieringConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketIntelligentTieringConfiguration), arg0)
}

// GetBucketIntelligentTieringConfigurationRequest mocks base method.
func (m *MockS3) GetBucketIntelligentTieringConfigurationRequest(arg0 *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketIntelligentTieringConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketIntelligentTieringConfigurationOutput)
	return ret0, ret1
}

// GetBucketIntelligentTieringConfigurationRequest indicates an expected call of GetBucketIntelligentTieringConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketIntelligentTieringConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketIntelligentTieringConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketIntelligentTieringConfigurationRequest), arg0)
}

// GetBucketIntelligentTieringConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketIntelligentTieringConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketIntelligentTieringConfigurationInput, arg2 ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketIntelligentTieringConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketIntelligentTieringConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketIntelligentTieringConfigurationWithContext indicates an expected call of GetBucketIntelligentTieringConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketIntelligentTieringConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketIntelligentTieringConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketIntelligentTieringConfigurationWithContext), varargs...)
}

// GetBucketInventoryConfiguration mocks base method.
func (m *MockS3) GetBucketInventoryConfiguration(arg0 *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketInventoryConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetBucketInventoryConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketInventoryConfiguration indicates an expected call of GetBucketInventoryConfiguration.
func (mr *MockS3MockRecorder) GetBucketInventoryConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketInventoryConfiguration), arg0)
}

// GetBucketInventoryConfigurationRequest mocks base method.
func (m *MockS3) GetBucketInventoryConfigurationRequest(arg0 *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketInventoryConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketInventoryConfigurationOutput)
	return ret0, ret1
}

// GetBucketInventoryConfigurationRequest indicates an expected call of GetBucketInventoryConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketInventoryConfigurationRequest), arg0)
}

// GetBucketInventoryConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketInventoryConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketInventoryConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketInventoryConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketInventoryConfigurationWithContext indicates an expected call of GetBucketInventoryConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketInventoryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketInventoryConfigurationWithContext), varargs...)
}

// GetBucketLifecycle mocks base method.
func (m *MockS3) GetBucketLifecycle(arg0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLifecycle", arg0)
	ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLifecycle indicates an expected call of GetBucketLifecycle.
func (mr *MockS3MockRecorder) GetBucketLifecycle(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycle", reflect.TypeOf((*MockS3)(nil).GetBucketLifecycle), arg0)
}

// GetBucketLifecycleConfiguration mocks base method.
func (m *MockS3) GetBucketLifecycleConfiguration(arg0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLifecycleConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLifecycleConfiguration indicates an expected call of GetBucketLifecycleConfiguration.
func (mr *MockS3MockRecorder) GetBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketLifecycleConfiguration), arg0)
}

// GetBucketLifecycleConfigurationRequest mocks base method.
func (m *MockS3) GetBucketLifecycleConfigurationRequest(arg0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLifecycleConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLifecycleConfigurationOutput)
	return ret0, ret1
}

// GetBucketLifecycleConfigurationRequest indicates an expected call of GetBucketLifecycleConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketLifecycleConfigurationRequest), arg0)
}

// GetBucketLifecycleConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketLifecycleConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketLifecycleConfigurationInput, arg2 ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketLifecycleConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLifecycleConfigurationWithContext indicates an expected call of GetBucketLifecycleConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketLifecycleConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketLifecycleConfigurationWithContext), varargs...)
}

// GetBucketLifecycleRequest mocks base method.
func (m *MockS3) GetBucketLifecycleRequest(arg0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLifecycleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLifecycleOutput)
	return ret0, ret1
}

// GetBucketLifecycleRequest indicates an expected call of GetBucketLifecycleRequest.
func (mr *MockS3MockRecorder) GetBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleRequest", reflect.TypeOf((*MockS3)(nil).GetBucketLifecycleRequest), arg0)
}

// GetBucketLifecycleWithContext mocks base method.
func (m *MockS3) GetBucketLifecycleWithContext(arg0 context.Context, arg1 *s3.GetBucketLifecycleInput, arg2 ...request.Option) (*s3.GetBucketLifecycleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketLifecycleWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLifecycleWithContext indicates an expected call of GetBucketLifecycleWithContext.
func (mr *MockS3MockRecorder) GetBucketLifecycleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketLifecycleWithContext), varargs...)
}

// GetBucketLocation mocks base method.
func (m *MockS3) GetBucketLocation(arg0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLocation", arg0)
	ret0, _ := ret[0].(*s3.GetBucketLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLocation indicates an expected call of GetBucketLocation.
func (mr *MockS3MockRecorder) GetBucketLocation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocation", reflect.TypeOf((*MockS3)(nil).GetBucketLocation), arg0)
}

// GetBucketLocationRequest mocks base method.
func (m *MockS3) GetBucketLocationRequest(arg0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLocationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLocationOutput)
	return ret0, ret1
}

// GetBucketLocationRequest indicates an expected call of GetBucketLocationRequest.
func (mr *MockS3MockRecorder) GetBucketLocationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketLocationRequest), arg0)
}

// GetBucketLocationWithContext mocks base method.
func (m *MockS3) GetBucketLocationWithContext(arg0 context.Context, arg1 *s3.GetBucketLocationInput, arg2 ...request.Option) (*s3.GetBucketLocationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketLocationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLocationWithContext indicates an expected call of GetBucketLocationWithContext.
func (mr *MockS3MockRecorder) GetBucketLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketLocationWithContext), varargs...)
}

// GetBucketLogging mocks base method.
func (m *MockS3) GetBucketLogging(arg0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLogging", arg0)
	ret0, _ := ret[0].(*s3.GetBucketLoggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLogging indicates an expected call of GetBucketLogging.
func (mr *MockS3MockRecorder) GetBucketLogging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLogging", reflect.TypeOf((*MockS3)(nil).GetBucketLogging), arg0)
}

// GetBucketLoggingRequest mocks base method.
func (m *MockS3) GetBucketLoggingRequest(arg0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketLoggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketLoggingOutput)
	return ret0, ret1
}

// GetBucketLoggingRequest indicates an expected call of GetBucketLoggingRequest.
func (mr *MockS3MockRecorder) GetBucketLoggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLoggingRequest", reflect.TypeOf((*MockS3)(nil).GetBucketLoggingRequest), arg0)
}

// GetBucketLoggingWithContext mocks base method.
func (m *MockS3) GetBucketLoggingWithContext(arg0 context.Context, arg1 *s3.GetBucketLoggingInput, arg2 ...request.Option) (*s3.GetBucketLoggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketLoggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketLoggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketLoggingWithContext indicates an expected call of GetBucketLoggingWithContext.
func (mr *MockS3MockRecorder) GetBucketLoggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLoggingWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketLoggingWithContext), varargs...)
}

// GetBucketMetricsConfiguration mocks base method.
func (m *MockS3) GetBucketMetricsConfiguration(arg0 *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketMetricsConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetBucketMetricsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketMetricsConfiguration indicates an expected call of GetBucketMetricsConfiguration.
func (mr *MockS3MockRecorder) GetBucketMetricsConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketMetricsConfiguration), arg0)
}

// GetBucketMetricsConfigurationRequest mocks base method.
func (m *MockS3) GetBucketMetricsConfigurationRequest(arg0 *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketMetricsConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketMetricsConfigurationOutput)
	return ret0, ret1
}

// GetBucketMetricsConfigurationRequest indicates an expected call of GetBucketMetricsConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketMetricsConfigurationRequest), arg0)
}

// GetBucketMetricsConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketMetricsConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketMetricsConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketMetricsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketMetricsConfigurationWithContext indicates an expected call of GetBucketMetricsConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketMetricsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketMetricsConfigurationWithContext), varargs...)
}

// GetBucketNotification mocks base method.
func (m *MockS3) GetBucketNotification(arg0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketNotification", arg0)
	ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketNotification indicates an expected call of GetBucketNotification.
func (mr *MockS3MockRecorder) GetBucketNotification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotification", reflect.TypeOf((*MockS3)(nil).GetBucketNotification), arg0)
}

// GetBucketNotificationConfiguration mocks base method.
func (m *MockS3) GetBucketNotificationConfiguration(arg0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketNotificationConfiguration", arg0)
	ret0, _ := ret[0].(*s3.NotificationConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketNotificationConfiguration indicates an expected call of GetBucketNotificationConfiguration.
func (mr *MockS3MockRecorder) GetBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfiguration", reflect.TypeOf((*MockS3)(nil).GetBucketNotificationConfiguration), arg0)
}

// GetBucketNotificationConfigurationRequest mocks base method.
func (m *MockS3) GetBucketNotificationConfigurationRequest(arg0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketNotificationConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.NotificationConfiguration)
	return ret0, ret1
}

// GetBucketNotificationConfigurationRequest indicates an expected call of GetBucketNotificationConfigurationRequest.
func (mr *MockS3MockRecorder) GetBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketNotificationConfigurationRequest), arg0)
}

// GetBucketNotificationConfigurationWithContext mocks base method.
func (m *MockS3) GetBucketNotificationConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketNotificationConfigurationRequest, arg2 ...request.Option) (*s3.NotificationConfiguration, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketNotificationConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.NotificationConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketNotificationConfigurationWithContext indicates an expected call of GetBucketNotificationConfigurationWithContext.
func (mr *MockS3MockRecorder) GetBucketNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketNotificationConfigurationWithContext), varargs...)
}

// GetBucketNotificationRequest mocks base method.
func (m *MockS3) GetBucketNotificationRequest(arg0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.NotificationConfigurationDeprecated)
	return ret0, ret1
}

// GetBucketNotificationRequest indicates an expected call of GetBucketNotificationRequest.
func (mr *MockS3MockRecorder) GetBucketNotificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketNotificationRequest), arg0)
}

// GetBucketNotificationWithContext mocks base method.
func (m *MockS3) GetBucketNotificationWithContext(arg0 context.Context, arg1 *s3.GetBucketNotificationConfigurationRequest, arg2 ...request.Option) (*s3.NotificationConfigurationDeprecated, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketNotificationWithContext indicates an expected call of GetBucketNotificationWithContext.
func (mr *MockS3MockRecorder) GetBucketNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketNotificationWithContext), varargs...)
}

// GetBucketOwnershipControls mocks base method.
func (m *MockS3) GetBucketOwnershipControls(arg0 *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketOwnershipControls", arg0)
	ret0, _ := ret[0].(*s3.GetBucketOwnershipControlsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketOwnershipControls indicates an expected call of GetBucketOwnershipControls.
func (mr *MockS3MockRecorder) GetBucketOwnershipControls(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketOwnershipControls", reflect.TypeOf((*MockS3)(nil).GetBucketOwnershipControls), arg0)
}

// GetBucketOwnershipControlsRequest mocks base method.
func (m *MockS3) GetBucketOwnershipControlsRequest(arg0 *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketOwnershipControlsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketOwnershipControlsOutput)
	return ret0, ret1
}

// GetBucketOwnershipControlsRequest indicates an expected call of GetBucketOwnershipControlsRequest.
func (mr *MockS3MockRecorder) GetBucketOwnershipControlsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketOwnershipControlsRequest", reflect.TypeOf((*MockS3)(nil).GetBucketOwnershipControlsRequest), arg0)
}

// GetBucketOwnershipControlsWithContext mocks base method.
func (m *MockS3) GetBucketOwnershipControlsWithContext(arg0 context.Context, arg1 *s3.GetBucketOwnershipControlsInput, arg2 ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketOwnershipControlsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketOwnershipControlsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketOwnershipControlsWithContext indicates an expected call of GetBucketOwnershipControlsWithContext.
func (mr *MockS3MockRecorder) GetBucketOwnershipControlsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketOwnershipControlsWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketOwnershipControlsWithContext), varargs...)
}

// GetBucketPolicy mocks base method.
func (m *MockS3) GetBucketPolicy(arg0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketPolicy", arg0)
	ret0, _ := ret[0].(*s3.GetBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketPolicy indicates an expected call of GetBucketPolicy.
func (mr *MockS3MockRecorder) GetBucketPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicy", reflect.TypeOf((*MockS3)(nil).GetBucketPolicy), arg0)
}

// GetBucketPolicyRequest mocks base method.
func (m *MockS3) GetBucketPolicyRequest(arg0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketPolicyOutput)
	return ret0, ret1
}

// GetBucketPolicyRequest indicates an expected call of GetBucketPolicyRequest.
func (mr *MockS3MockRecorder) GetBucketPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyRequest", reflect.TypeOf((*MockS3)(nil).GetBucketPolicyRequest), arg0)
}

// GetBucketPolicyStatus mocks base method.
func (m *MockS3) GetBucketPolicyStatus(arg0 *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketPolicyStatus", arg0)
	ret0, _ := ret[0].(*s3.GetBucketPolicyStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketPolicyStatus indicates an expected call of GetBucketPolicyStatus.
func (mr *MockS3MockRecorder) GetBucketPolicyStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyStatus", reflect.TypeOf((*MockS3)(nil).GetBucketPolicyStatus), arg0)
}

// GetBucketPolicyStatusRequest mocks base method.
func (m *MockS3) GetBucketPolicyStatusRequest(arg0 *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketPolicyStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketPolicyStatusOutput)
	return ret0, ret1
}

// GetBucketPolicyStatusRequest indicates an expected call of GetBucketPolicyStatusRequest.
func (mr *MockS3MockRecorder) GetBucketPolicyStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyStatusRequest", reflect.TypeOf((*MockS3)(nil).GetBucketPolicyStatusRequest), arg0)
}

// GetBucketPolicyStatusWithContext mocks base method.
func (m *MockS3) GetBucketPolicyStatusWithContext(arg0 context.Context, arg1 *s3.GetBucketPolicyStatusInput, arg2 ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketPolicyStatusWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketPolicyStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketPolicyStatusWithContext indicates an expected call of GetBucketPolicyStatusWithContext.
func (mr *MockS3MockRecorder) GetBucketPolicyStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyStatusWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketPolicyStatusWithContext), varargs...)
}

// GetBucketPolicyWithContext mocks base method.
func (m *MockS3) GetBucketPolicyWithContext(arg0 context.Context, arg1 *s3.GetBucketPolicyInput, arg2 ...request.Option) (*s3.GetBucketPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketPolicyWithContext indicates an expected call of GetBucketPolicyWithContext.
func (mr *MockS3MockRecorder) GetBucketPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketPolicyWithContext), varargs...)
}

// GetBucketReplication mocks base method.
func (m *MockS3) GetBucketReplication(arg0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketReplication", arg0)
	ret0, _ := ret[0].(*s3.GetBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketReplication indicates an expected call of GetBucketReplication.
func (mr *MockS3MockRecorder) GetBucketReplication(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplication", reflect.TypeOf((*MockS3)(nil).GetBucketReplication), arg0)
}

// GetBucketReplicationRequest mocks base method.
func (m *MockS3) GetBucketReplicationRequest(arg0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketReplicationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketReplicationOutput)
	return ret0, ret1
}

// GetBucketReplicationRequest indicates an expected call of GetBucketReplicationRequest.
func (mr *MockS3MockRecorder) GetBucketReplicationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplicationRequest", reflect.TypeOf((*MockS3)(nil).GetBucketReplicationRequest), arg0)
}

// GetBucketReplicationWithContext mocks base method.
func (m *MockS3) GetBucketReplicationWithContext(arg0 context.Context, arg1 *s3.GetBucketReplicationInput, arg2 ...request.Option) (*s3.GetBucketReplicationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketReplicationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketReplicationWithContext indicates an expected call of GetBucketReplicationWithContext.
func (mr *MockS3MockRecorder) GetBucketReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplicationWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketReplicationWithContext), varargs...)
}

// GetBucketRequestPayment mocks base method.
func (m *MockS3) GetBucketRequestPayment(arg0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketRequestPayment", arg0)
	ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketRequestPayment indicates an expected call of GetBucketRequestPayment.
func (mr *MockS3MockRecorder) GetBucketRequestPayment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPayment", reflect.TypeOf((*MockS3)(nil).GetBucketRequestPayment), arg0)
}

// GetBucketRequestPaymentRequest mocks base method.
func (m *MockS3) GetBucketRequestPaymentRequest(arg0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketRequestPaymentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketRequestPaymentOutput)
	return ret0, ret1
}

// GetBucketRequestPaymentRequest indicates an expected call of GetBucketRequestPaymentRequest.
func (mr *MockS3MockRecorder) GetBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPaymentRequest", reflect.TypeOf((*MockS3)(nil).GetBucketRequestPaymentRequest), arg0)
}

// GetBucketRequestPaymentWithContext mocks base method.
func (m *MockS3) GetBucketRequestPaymentWithContext(arg0 context.Context, arg1 *s3.GetBucketRequestPaymentInput, arg2 ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketRequestPaymentWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketRequestPaymentWithContext indicates an expected call of GetBucketRequestPaymentWithContext.
func (mr *MockS3MockRecorder) GetBucketRequestPaymentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPaymentWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketRequestPaymentWithContext), varargs...)
}

// GetBucketTagging mocks base method.
func (m *MockS3) GetBucketTagging(arg0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketTagging", arg0)
	ret0, _ := ret[0].(*s3.GetBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketTagging indicates an expected call of GetBucketTagging.
func (mr *MockS3MockRecorder) GetBucketTagging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTagging", reflect.TypeOf((*MockS3)(nil).GetBucketTagging), arg0)
}

// GetBucketTaggingRequest mocks base method.
func (m *MockS3) GetBucketTaggingRequest(arg0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketTaggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketTaggingOutput)
	return ret0, ret1
}

// GetBucketTaggingRequest indicates an expected call of GetBucketTaggingRequest.
func (mr *MockS3MockRecorder) GetBucketTaggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTaggingRequest", reflect.TypeOf((*MockS3)(nil).GetBucketTaggingRequest), arg0)
}

// GetBucketTaggingWithContext mocks base method.
func (m *MockS3) GetBucketTaggingWithContext(arg0 context.Context, arg1 *s3.GetBucketTaggingInput, arg2 ...request.Option) (*s3.GetBucketTaggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketTaggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketTaggingWithContext indicates an expected call of GetBucketTaggingWithContext.
func (mr *MockS3MockRecorder) GetBucketTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTaggingWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketTaggingWithContext), varargs...)
}

// GetBucketVersioning mocks base method.
func (m *MockS3) GetBucketVersioning(arg0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketVersioning", arg0)
	ret0, _ := ret[0].(*s3.GetBucketVersioningOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketVersioning indicates an expected call of GetBucketVersioning.
func (mr *MockS3MockRecorder) GetBucketVersioning(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioning", reflect.TypeOf((*MockS3)(nil).GetBucketVersioning), arg0)
}

// GetBucketVersioningRequest mocks base method.
func (m *MockS3) GetBucketVersioningRequest(arg0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketVersioningRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketVersioningOutput)
	return ret0, ret1
}

// GetBucketVersioningRequest indicates an expected call of GetBucketVersioningRequest.
func (mr *MockS3MockRecorder) GetBucketVersioningRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioningRequest", reflect.TypeOf((*MockS3)(nil).GetBucketVersioningRequest), arg0)
}

// GetBucketVersioningWithContext mocks base method.
func (m *MockS3) GetBucketVersioningWithContext(arg0 context.Context, arg1 *s3.GetBucketVersioningInput, arg2 ...request.Option) (*s3.GetBucketVersioningOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketVersioningWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketVersioningOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketVersioningWithContext indicates an expected call of GetBucketVersioningWithContext.
func (mr *MockS3MockRecorder) GetBucketVersioningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioningWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketVersioningWithContext), varargs...)
}

// GetBucketWebsite mocks base method.
func (m *MockS3) GetBucketWebsite(arg0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketWebsite", arg0)
	ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketWebsite indicates an expected call of GetBucketWebsite.
func (mr *MockS3MockRecorder) GetBucketWebsite(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsite", reflect.TypeOf((*MockS3)(nil).GetBucketWebsite), arg0)
}

// GetBucketWebsiteRequest mocks base method.
func (m *MockS3) GetBucketWebsiteRequest(arg0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketWebsiteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetBucketWebsiteOutput)
	return ret0, ret1
}

// GetBucketWebsiteRequest indicates an expected call of GetBucketWebsiteRequest.
func (mr *MockS3MockRecorder) GetBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsiteRequest", reflect.TypeOf((*MockS3)(nil).GetBucketWebsiteRequest), arg0)
}

// GetBucketWebsiteWithContext mocks base method.
func (m *MockS3) GetBucketWebsiteWithContext(arg0 context.Context, arg1 *s3.GetBucketWebsiteInput, arg2 ...request.Option) (*s3.GetBucketWebsiteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketWebsiteWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketWebsiteWithContext indicates an expected call of GetBucketWebsiteWithContext.
func (mr *MockS3MockRecorder) GetBucketWebsiteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsiteWithContext", reflect.TypeOf((*MockS3)(nil).GetBucketWebsiteWithContext), varargs...)
}

// GetObject mocks base method.
func (m *MockS3) GetObject(arg0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObject", arg0)
	ret0, _ := ret[0].(*s3.GetObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObject indicates an expected call of GetObject.
func (mr *MockS3MockRecorder) GetObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockS3)(nil).GetObject), arg0)
}

// GetObjectAcl mocks base method.
func (m *MockS3) GetObjectAcl(arg0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectAcl", arg0)
	ret0, _ := ret[0].(*s3.GetObjectAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectAcl indicates an expected call of GetObjectAcl.
func (mr *MockS3MockRecorder) GetObjectAcl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAcl", reflect.TypeOf((*MockS3)(nil).GetObjectAcl), arg0)
}

// GetObjectAclRequest mocks base method.
func (m *MockS3) GetObjectAclRequest(arg0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectAclRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectAclOutput)
	return ret0, ret1
}

// GetObjectAclRequest indicates an expected call of GetObjectAclRequest.
func (mr *MockS3MockRecorder) GetObjectAclRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAclRequest", reflect.TypeOf((*MockS3)(nil).GetObjectAclRequest), arg0)
}

// GetObjectAclWithContext mocks base method.
func (m *MockS3) GetObjectAclWithContext(arg0 context.Context, arg1 *s3.GetObjectAclInput, arg2 ...request.Option) (*s3.GetObjectAclOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectAclWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectAclWithContext indicates an expected call of GetObjectAclWithContext.
func (mr *MockS3MockRecorder) GetObjectAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAclWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectAclWithContext), varargs...)
}

// GetObjectAttributes mocks base method.
func (m *MockS3) GetObjectAttributes(arg0 *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectAttributes", arg0)
	ret0, _ := ret[0].(*s3.GetObjectAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectAttributes indicates an expected call of GetObjectAttributes.
func (mr *MockS3MockRecorder) GetObjectAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAttributes", reflect.TypeOf((*MockS3)(nil).GetObjectAttributes), arg0)
}

// GetObjectAttributesRequest mocks base method.
func (m *MockS3) GetObjectAttributesRequest(arg0 *s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectAttributesOutput)
	return ret0, ret1
}

// GetObjectAttributesRequest indicates an expected call of GetObjectAttributesRequest.
func (mr *MockS3MockRecorder) GetObjectAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAttributesRequest", reflect.TypeOf((*MockS3)(nil).GetObjectAttributesRequest), arg0)
}

// GetObjectAttributesWithContext mocks base method.
func (m *MockS3) GetObjectAttributesWithContext(arg0 context.Context, arg1 *s3.GetObjectAttributesInput, arg2 ...request.Option) (*s3.GetObjectAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectAttributesWithContext indicates an expected call of GetObjectAttributesWithContext.
func (mr *MockS3MockRecorder) GetObjectAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAttributesWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectAttributesWithContext), varargs...)
}

// GetObjectLegalHold mocks base method.
func (m *MockS3) GetObjectLegalHold(arg0 *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectLegalHold", arg0)
	ret0, _ := ret[0].(*s3.GetObjectLegalHoldOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectLegalHold indicates an expected call of GetObjectLegalHold.
func (mr *MockS3MockRecorder) GetObjectLegalHold(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLegalHold", reflect.TypeOf((*MockS3)(nil).GetObjectLegalHold), arg0)
}

// GetObjectLegalHoldRequest mocks base method.
func (m *MockS3) GetObjectLegalHoldRequest(arg0 *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectLegalHoldRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectLegalHoldOutput)
	return ret0, ret1
}

// GetObjectLegalHoldRequest indicates an expected call of GetObjectLegalHoldRequest.
func (mr *MockS3MockRecorder) GetObjectLegalHoldRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLegalHoldRequest", reflect.TypeOf((*MockS3)(nil).GetObjectLegalHoldRequest), arg0)
}

// GetObjectLegalHoldWithContext mocks base method.
func (m *MockS3) GetObjectLegalHoldWithContext(arg0 context.Context, arg1 *s3.GetObjectLegalHoldInput, arg2 ...request.Option) (*s3.GetObjectLegalHoldOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectLegalHoldWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectLegalHoldOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectLegalHoldWithContext indicates an expected call of GetObjectLegalHoldWithContext.
func (mr *MockS3MockRecorder) GetObjectLegalHoldWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLegalHoldWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectLegalHoldWithContext), varargs...)
}

// GetObjectLockConfiguration mocks base method.
func (m *MockS3) GetObjectLockConfiguration(arg0 *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectLockConfiguration", arg0)
	ret0, _ := ret[0].(*s3.GetObjectLockConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectLockConfiguration indicates an expected call of GetObjectLockConfiguration.
func (mr *MockS3MockRecorder) GetObjectLockConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLockConfiguration", reflect.TypeOf((*MockS3)(nil).GetObjectLockConfiguration), arg0)
}

// GetObjectLockConfigurationRequest mocks base method.
func (m *MockS3) GetObjectLockConfigurationRequest(arg0 *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectLockConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectLockConfigurationOutput)
	return ret0, ret1
}

// GetObjectLockConfigurationRequest indicates an expected call of GetObjectLockConfigurationRequest.
func (mr *MockS3MockRecorder) GetObjectLockConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLockConfigurationRequest", reflect.TypeOf((*MockS3)(nil).GetObjectLockConfigurationRequest), arg0)
}

// GetObjectLockConfigurationWithContext mocks base method.
func (m *MockS3) GetObjectLockConfigurationWithContext(arg0 context.Context, arg1 *s3.GetObjectLockConfigurationInput, arg2 ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectLockConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectLockConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectLockConfigurationWithContext indicates an expected call of GetObjectLockConfigurationWithContext.
func (mr *MockS3MockRecorder) GetObjectLockConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLockConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectLockConfigurationWithContext), varargs...)
}

// GetObjectRequest mocks base method.
func (m *MockS3) GetObjectRequest(arg0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectOutput)
	return ret0, ret1
}

// GetObjectRequest indicates an expected call of GetObjectRequest.
func (mr *MockS3MockRecorder) GetObjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRequest", reflect.TypeOf((*MockS3)(nil).GetObjectRequest), arg0)
}

// GetObjectRetention mocks base method.
func (m *MockS3) GetObjectRetention(arg0 *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectRetention", arg0)
	ret0, _ := ret[0].(*s3.GetObjectRetentionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectRetention indicates an expected call of GetObjectRetention.
func (mr *MockS3MockRecorder) GetObjectRetention(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRetention", reflect.TypeOf((*MockS3)(nil).GetObjectRetention), arg0)
}

// GetObjectRetentionRequest mocks base method.
func (m *MockS3) GetObjectRetentionRequest(arg0 *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectRetentionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectRetentionOutput)
	return ret0, ret1
}

// GetObjectRetentionRequest indicates an expected call of GetObjectRetentionRequest.
func (mr *MockS3MockRecorder) GetObjectRetentionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRetentionRequest", reflect.TypeOf((*MockS3)(nil).GetObjectRetentionRequest), arg0)
}

// GetObjectRetentionWithContext mocks base method.
func (m *MockS3) GetObjectRetentionWithContext(arg0 context.Context, arg1 *s3.GetObjectRetentionInput, arg2 ...request.Option) (*s3.GetObjectRetentionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectRetentionWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectRetentionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectRetentionWithContext indicates an expected call of GetObjectRetentionWithContext.
func (mr *MockS3MockRecorder) GetObjectRetentionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRetentionWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectRetentionWithContext), varargs...)
}

// GetObjectTagging mocks base method.
func (m *MockS3) GetObjectTagging(arg0 *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTagging", arg0)
	ret0, _ := ret[0].(*s3.GetObjectTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTagging indicates an expected call of GetObjectTagging.
func (mr *MockS3MockRecorder) GetObjectTagging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTagging", reflect.TypeOf((*MockS3)(nil).GetObjectTagging), arg0)
}

// GetObjectTaggingRequest mocks base method.
func (m *MockS3) GetObjectTaggingRequest(arg0 *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTaggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectTaggingOutput)
	return ret0, ret1
}

// GetObjectTaggingRequest indicates an expected call of GetObjectTaggingRequest.
func (mr *MockS3MockRecorder) GetObjectTaggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTaggingRequest", reflect.TypeOf((*MockS3)(nil).GetObjectTaggingRequest), arg0)
}

// GetObjectTaggingWithContext mocks base method.
func (m *MockS3) GetObjectTaggingWithContext(arg0 context.Context, arg1 *s3.GetObjectTaggingInput, arg2 ...request.Option) (*s3.GetObjectTaggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectTaggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTaggingWithContext indicates an expected call of GetObjectTaggingWithContext.
func (mr *MockS3MockRecorder) GetObjectTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTaggingWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectTaggingWithContext), varargs...)
}

// GetObjectTorrent mocks base method.
func (m *MockS3) GetObjectTorrent(arg0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTorrent", arg0)
	ret0, _ := ret[0].(*s3.GetObjectTorrentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTorrent indicates an expected call of GetObjectTorrent.
func (mr *MockS3MockRecorder) GetObjectTorrent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrent", reflect.TypeOf((*MockS3)(nil).GetObjectTorrent), arg0)
}

// GetObjectTorrentRequest mocks base method.
func (m *MockS3) GetObjectTorrentRequest(arg0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTorrentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetObjectTorrentOutput)
	return ret0, ret1
}

// GetObjectTorrentRequest indicates an expected call of GetObjectTorrentRequest.
func (mr *MockS3MockRecorder) GetObjectTorrentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrentRequest", reflect.TypeOf((*MockS3)(nil).GetObjectTorrentRequest), arg0)
}

// GetObjectTorrentWithContext mocks base method.
func (m *MockS3) GetObjectTorrentWithContext(arg0 context.Context, arg1 *s3.GetObjectTorrentInput, arg2 ...request.Option) (*s3.GetObjectTorrentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectTorrentWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectTorrentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTorrentWithContext indicates an expected call of GetObjectTorrentWithContext.
func (mr *MockS3MockRecorder) GetObjectTorrentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrentWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectTorrentWithContext), varargs...)
}

// GetObjectWithContext mocks base method.
func (m *MockS3) GetObjectWithContext(arg0 context.Context, arg1 *s3.GetObjectInput, arg2 ...request.Option) (*s3.GetObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectWithContext indicates an expected call of GetObjectWithContext.
func (mr *MockS3MockRecorder) GetObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectWithContext", reflect.TypeOf((*MockS3)(nil).GetObjectWithContext), varargs...)
}

// GetPublicAccessBlock mocks base method.
func (m *MockS3) GetPublicAccessBlock(arg0 *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicAccessBlock", arg0)
	ret0, _ := ret[0].(*s3.GetPublicAccessBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPublicAccessBlock indicates an expected call of GetPublicAccessBlock.
func (mr *MockS3MockRecorder) GetPublicAccessBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicAccessBlock", reflect.TypeOf((*MockS3)(nil).GetPublicAccessBlock), arg0)
}

// GetPublicAccessBlockRequest mocks base method.
func (m *MockS3) GetPublicAccessBlockRequest(arg0 *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicAccessBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.GetPublicAccessBlockOutput)
	return ret0, ret1
}

// GetPublicAccessBlockRequest indicates an expected call of GetPublicAccessBlockRequest.
func (mr *MockS3MockRecorder) GetPublicAccessBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicAccessBlockRequest", reflect.TypeOf((*MockS3)(nil).GetPublicAccessBlockRequest), arg0)
}

// GetPublicAccessBlockWithContext mocks base method.
func (m *MockS3) GetPublicAccessBlockWithContext(arg0 context.Context, arg1 *s3.GetPublicAccessBlockInput, arg2 ...request.Option) (*s3.GetPublicAccessBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPublicAccessBlockWithContext", varargs...)
	ret0, _ := ret[0].(*s3.GetPublicAccessBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPublicAccessBlockWithContext indicates an expected call of GetPublicAccessBlockWithContext.
func (mr *MockS3MockRecorder) GetPublicAccessBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicAccessBlockWithContext", reflect.TypeOf((*MockS3)(nil).GetPublicAccessBlockWithContext), varargs...)
}

// HeadBucket mocks base method.
func (m *MockS3) HeadBucket(arg0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadBucket", arg0)
	ret0, _ := ret[0].(*s3.HeadBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeadBucket indicates an expected call of HeadBucket.
func (mr *MockS3MockRecorder) HeadBucket(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucket", reflect.TypeOf((*MockS3)(nil).HeadBucket), arg0)
}

// HeadBucketRequest mocks base method.
func (m *MockS3) HeadBucketRequest(arg0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadBucketRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.HeadBucketOutput)
	return ret0, ret1
}

// HeadBucketRequest indicates an expected call of HeadBucketRequest.
func (mr *MockS3MockRecorder) HeadBucketRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucketRequest", reflect.TypeOf((*MockS3)(nil).HeadBucketRequest), arg0)
}

// HeadBucketWithContext mocks base method.
func (m *MockS3) HeadBucketWithContext(arg0 context.Context, arg1 *s3.HeadBucketInput, arg2 ...request.Option) (*s3.HeadBucketOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HeadBucketWithContext", varargs...)
	ret0, _ := ret[0].(*s3.HeadBucketOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeadBucketWithContext indicates an expected call of HeadBucketWithContext.
func (mr *MockS3MockRecorder) HeadBucketWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucketWithContext", reflect.TypeOf((*MockS3)(nil).HeadBucketWithContext), varargs...)
}

// HeadObject mocks base method.
func (m *MockS3) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadObject", arg0)
	ret0, _ := ret[0].(*s3.HeadObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeadObject indicates an expected call of HeadObject.
func (mr *MockS3MockRecorder) HeadObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockS3)(nil).HeadObject), arg0)
}

// HeadObjectRequest mocks base method.
func (m *MockS3) HeadObjectRequest(arg0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadObjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.HeadObjectOutput)
	return ret0, ret1
}

// HeadObjectRequest indicates an expected call of HeadObjectRequest.
func (mr *MockS3MockRecorder) HeadObjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObjectRequest", reflect.TypeOf((*MockS3)(nil).HeadObjectRequest), arg0)
}

// HeadObjectWithContext mocks base method.
func (m *MockS3) HeadObjectWithContext(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...request.Option) (*s3.HeadObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HeadObjectWithContext", varargs...)
	ret0, _ := ret[0].(*s3.HeadObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeadObjectWithContext indicates an expected call of HeadObjectWithContext.
func (mr *MockS3MockRecorder) HeadObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObjectWithContext", reflect.TypeOf((*MockS3)(nil).HeadObjectWithContext), varargs...)
}

// ListBucketAnalyticsConfigurations mocks base method.
func (m *MockS3) ListBucketAnalyticsConfigurations(arg0 *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurations", arg0)
	ret0, _ := ret[0].(*s3.ListBucketAnalyticsConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketAnalyticsConfigurations indicates an expected call of ListBucketAnalyticsConfigurations.
func (mr *MockS3MockRecorder) ListBucketAnalyticsConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurations", reflect.TypeOf((*MockS3)(nil).ListBucketAnalyticsConfigurations), arg0)
}

// ListBucketAnalyticsConfigurationsRequest mocks base method.
func (m *MockS3) ListBucketAnalyticsConfigurationsRequest(arg0 *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListBucketAnalyticsConfigurationsOutput)
	return ret0, ret1
}

// ListBucketAnalyticsConfigurationsRequest indicates an expected call of ListBucketAnalyticsConfigurationsRequest.
func (mr *MockS3MockRecorder) ListBucketAnalyticsConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurationsRequest", reflect.TypeOf((*MockS3)(nil).ListBucketAnalyticsConfigurationsRequest), arg0)
}

// ListBucketAnalyticsConfigurationsWithContext mocks base method.
func (m *MockS3) ListBucketAnalyticsConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketAnalyticsConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListBucketAnalyticsConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketAnalyticsConfigurationsWithContext indicates an expected call of ListBucketAnalyticsConfigurationsWithContext.
func (mr *MockS3MockRecorder) ListBucketAnalyticsConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurationsWithContext", reflect.TypeOf((*MockS3)(nil).ListBucketAnalyticsConfigurationsWithContext), varargs...)
}

// ListBucketIntelligentTieringConfigurations mocks base method.
func (m *MockS3) ListBucketIntelligentTieringConfigurations(arg0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketIntelligentTieringConfigurations", arg0)
	ret0, _ := ret[0].(*s3.ListBucketIntelligentTieringConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketIntelligentTieringConfigurations indicates an expected call of ListBucketIntelligentTieringConfigurations.
func (mr *MockS3MockRecorder) ListBucketIntelligentTieringConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketIntelligentTieringConfigurations", reflect.TypeOf((*MockS3)(nil).ListBucketIntelligentTieringConfigurations), arg0)
}

// ListBucketIntelligentTieringConfigurationsRequest mocks base method.
func (m *MockS3) ListBucketIntelligentTieringConfigurationsRequest(arg0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketIntelligentTieringConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListBucketIntelligentTieringConfigurationsOutput)
	return ret0, ret1
}

// ListBucketIntelligentTieringConfigurationsRequest indicates an expected call of ListBucketIntelligentTieringConfigurationsRequest.
func (mr *MockS3MockRecorder) ListBucketIntelligentTieringConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketIntelligentTieringConfigurationsRequest", reflect.TypeOf((*MockS3)(nil).ListBucketIntelligentTieringConfigurationsRequest), arg0)
}

// ListBucketIntelligentTieringConfigurationsWithContext mocks base method.
func (m *MockS3) ListBucketIntelligentTieringConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketIntelligentTieringConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketIntelligentTieringConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListBucketIntelligentTieringConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketIntelligentTieringConfigurationsWithContext indicates an expected call of ListBucketIntelligentTieringConfigurationsWithContext.
func (mr *MockS3MockRecorder) ListBucketIntelligentTieringConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketIntelligentTieringConfigurationsWithContext", reflect.TypeOf((*MockS3)(nil).ListBucketIntelligentTieringConfigurationsWithContext), varargs...)
}

// ListBucketInventoryConfigurations mocks base method.
func (m *MockS3) ListBucketInventoryConfigurations(arg0 *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketInventoryConfigurations", arg0)
	ret0, _ := ret[0].(*s3.ListBucketInventoryConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketInventoryConfigurations indicates an expected call of ListBucketInventoryConfigurations.
func (mr *MockS3MockRecorder) ListBucketInventoryConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurations", reflect.TypeOf((*MockS3)(nil).ListBucketInventoryConfigurations), arg0)
}

// ListBucketInventoryConfigurationsRequest mocks base method.
func (m *MockS3) ListBucketInventoryConfigurationsRequest(arg0 *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketInventoryConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListBucketInventoryConfigurationsOutput)
	return ret0, ret1
}

// ListBucketInventoryConfigurationsRequest indicates an expected call of ListBucketInventoryConfigurationsRequest.
func (mr *MockS3MockRecorder) ListBucketInventoryConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurationsRequest", reflect.TypeOf((*MockS3)(nil).ListBucketInventoryConfigurationsRequest), arg0)
}

// ListBucketInventoryConfigurationsWithContext mocks base method.
func (m *MockS3) ListBucketInventoryConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketInventoryConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketInventoryConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListBucketInventoryConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketInventoryConfigurationsWithContext indicates an expected call of ListBucketInventoryConfigurationsWithContext.
func (mr *MockS3MockRecorder) ListBucketInventoryConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurationsWithContext", reflect.TypeOf((*MockS3)(nil).ListBucketInventoryConfigurationsWithContext), varargs...)
}

// ListBucketMetricsConfigurations mocks base method.
func (m *MockS3) ListBucketMetricsConfigurations(arg0 *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketMetricsConfigurations", arg0)
	ret0, _ := ret[0].(*s3.ListBucketMetricsConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketMetricsConfigurations indicates an expected call of ListBucketMetricsConfigurations.
func (mr *MockS3MockRecorder) ListBucketMetricsConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurations", reflect.TypeOf((*MockS3)(nil).ListBucketMetricsConfigurations), arg0)
}

// ListBucketMetricsConfigurationsRequest mocks base method.
func (m *MockS3) ListBucketMetricsConfigurationsRequest(arg0 *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketMetricsConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListBucketMetricsConfigurationsOutput)
	return ret0, ret1
}

// ListBucketMetricsConfigurationsRequest indicates an expected call of ListBucketMetricsConfigurationsRequest.
func (mr *MockS3MockRecorder) ListBucketMetricsConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurationsRequest", reflect.TypeOf((*MockS3)(nil).ListBucketMetricsConfigurationsRequest), arg0)
}

// ListBucketMetricsConfigurationsWithContext mocks base method.
func (m *MockS3) ListBucketMetricsConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketMetricsConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketMetricsConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListBucketMetricsConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketMetricsConfigurationsWithContext indicates an expected call of ListBucketMetricsConfigurationsWithContext.
func (mr *MockS3MockRecorder) ListBucketMetricsConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurationsWithContext", reflect.TypeOf((*MockS3)(nil).ListBucketMetricsConfigurationsWithContext), varargs...)
}

// ListBuckets mocks base method.
func (m *MockS3) ListBuckets(arg0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBuckets", arg0)
	ret0, _ := ret[0].(*s3.ListBucketsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBuckets indicates an expected call of ListBuckets.
func (mr *MockS3MockRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockS3)(nil).ListBuckets), arg0)
}

// ListBucketsRequest mocks base method.
func (m *MockS3) ListBucketsRequest(arg0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBucketsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListBucketsOutput)
	return ret0, ret1
}

// ListBucketsRequest indicates an expected call of ListBucketsRequest.
func (mr *MockS3MockRecorder) ListBucketsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsRequest", reflect.TypeOf((*MockS3)(nil).ListBucketsRequest), arg0)
}

// ListBucketsWithContext mocks base method.
func (m *MockS3) ListBucketsWithContext(arg0 context.Context, arg1 *s3.ListBucketsInput, arg2 ...request.Option) (*s3.ListBucketsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListBucketsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketsWithContext indicates an expected call of ListBucketsWithContext.
func (mr *MockS3MockRecorder) ListBucketsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsWithContext", reflect.TypeOf((*MockS3)(nil).ListBucketsWithContext), varargs...)
}

// ListMultipartUploads mocks base method.
func (m *MockS3) ListMultipartUploads(arg0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMultipartUploads", arg0)
	ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMultipartUploads indicates an expected call of ListMultipartUploads.
func (mr *MockS3MockRecorder) ListMultipartUploads(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploads", reflect.TypeOf((*MockS3)(nil).ListMultipartUploads), arg0)
}

// ListMultipartUploadsPages mocks base method.
func (m *MockS3) ListMultipartUploadsPages(arg0 *s3.ListMultipartUploadsInput, arg1 func(*s3.ListMultipartUploadsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMultipartUploadsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMultipartUploadsPages indicates an expected call of ListMultipartUploadsPages.
func (mr *MockS3MockRecorder) ListMultipartUploadsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsPages", reflect.TypeOf((*MockS3)(nil).ListMultipartUploadsPages), arg0, arg1)
}

// ListMultipartUploadsPagesWithContext mocks base method.
func (m *MockS3) ListMultipartUploadsPagesWithContext(arg0 context.Context, arg1 *s3.ListMultipartUploadsInput, arg2 func(*s3.ListMultipartUploadsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMultipartUploadsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListMultipartUploadsPagesWithContext indicates an expected call of ListMultipartUploadsPagesWithContext.
func (mr *MockS3MockRecorder) ListMultipartUploadsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsPagesWithContext", reflect.TypeOf((*MockS3)(nil).ListMultipartUploadsPagesWithContext), varargs...)
}

// ListMultipartUploadsRequest mocks base method.
func (m *MockS3) ListMultipartUploadsRequest(arg0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMultipartUploadsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListMultipartUploadsOutput)
	return ret0, ret1
}

// ListMultipartUploadsRequest indicates an expected call of ListMultipartUploadsRequest.
func (mr *MockS3MockRecorder) ListMultipartUploadsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsRequest", reflect.TypeOf((*MockS3)(nil).ListMultipartUploadsRequest), arg0)
}

// ListMultipartUploadsWithContext mocks base method.
func (m *MockS3) ListMultipartUploadsWithContext(arg0 context.Context, arg1 *s3.ListMultipartUploadsInput, arg2 ...request.Option) (*s3.ListMultipartUploadsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMultipartUploadsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMultipartUploadsWithContext indicates an expected call of ListMultipartUploadsWithContext.
func (mr *MockS3MockRecorder) ListMultipartUploadsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsWithContext", reflect.TypeOf((*MockS3)(nil).ListMultipartUploadsWithContext), varargs...)
}

// ListObjectVersions mocks base method.
func (m *MockS3) ListObjectVersions(arg0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectVersions", arg0)
	ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectVersions indicates an expected call of ListObjectVersions.
func (mr *MockS3MockRecorder) ListObjectVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersions", reflect.TypeOf((*MockS3)(nil).ListObjectVersions), arg0)
}

// ListObjectVersionsPages mocks base method.
func (m *MockS3) ListObjectVersionsPages(arg0 *s3.ListObjectVersionsInput, arg1 func(*s3.ListObjectVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListObjectVersionsPages indicates an expected call of ListObjectVersionsPages.
func (mr *MockS3MockRecorder) ListObjectVersionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsPages", reflect.TypeOf((*MockS3)(nil).ListObjectVersionsPages), arg0, arg1)
}

// ListObjectVersionsPagesWithContext mocks base method.
func (m *MockS3) ListObjectVersionsPagesWithContext(arg0 context.Context, arg1 *s3.ListObjectVersionsInput, arg2 func(*s3.ListObjectVersionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListObjectVersionsPagesWithContext indicates an expected call of ListObjectVersionsPagesWithContext.
func (mr *MockS3MockRecorder) ListObjectVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsPagesWithContext", reflect.TypeOf((*MockS3)(nil).ListObjectVersionsPagesWithContext), varargs...)
}

// ListObjectVersionsRequest mocks base method.
func (m *MockS3) ListObjectVersionsRequest(arg0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListObjectVersionsOutput)
	return ret0, ret1
}

// ListObjectVersionsRequest indicates an expected call of ListObjectVersionsRequest.
func (mr *MockS3MockRecorder) ListObjectVersionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsRequest", reflect.TypeOf((*MockS3)(nil).ListObjectVersionsRequest), arg0)
}

// ListObjectVersionsWithContext mocks base method.
func (m *MockS3) ListObjectVersionsWithContext(arg0 context.Context, arg1 *s3.ListObjectVersionsInput, arg2 ...request.Option) (*s3.ListObjectVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectVersionsWithContext indicates an expected call of ListObjectVersionsWithContext.
func (mr *MockS3MockRecorder) ListObjectVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsWithContext", reflect.TypeOf((*MockS3)(nil).ListObjectVersionsWithContext), varargs...)
}

// ListObjects mocks base method.
func (m *MockS3) ListObjects(arg0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjects", arg0)
	ret0, _ := ret[0].(*s3.ListObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjects indicates an expected call of ListObjects.
func (mr *MockS3MockRecorder) ListObjects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjects", reflect.TypeOf((*MockS3)(nil).ListObjects), arg0)
}

// ListObjectsPages mocks base method.
func (m *MockS3) ListObjectsPages(arg0 *s3.ListObjectsInput, arg1 func(*s3.ListObjectsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListObjectsPages indicates an expected call of ListObjectsPages.
func (mr *MockS3MockRecorder) ListObjectsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsPages", reflect.TypeOf((*MockS3)(nil).ListObjectsPages), arg0, arg1)
}

// ListObjectsPagesWithContext mocks base method.
func (m *MockS3) ListObjectsPagesWithContext(arg0 context.Context, arg1 *s3.ListObjectsInput, arg2 func(*s3.ListObjectsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListObjectsPagesWithContext indicates an expected call of ListObjectsPagesWithContext.
func (mr *MockS3MockRecorder) ListObjectsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsPagesWithContext", reflect.TypeOf((*MockS3)(nil).ListObjectsPagesWithContext), varargs...)
}

// ListObjectsRequest mocks base method.
func (m *MockS3) ListObjectsRequest(arg0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListObjectsOutput)
	return ret0, ret1
}

// ListObjectsRequest indicates an expected call of ListObjectsRequest.
func (mr *MockS3MockRecorder) ListObjectsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsRequest", reflect.TypeOf((*MockS3)(nil).ListObjectsRequest), arg0)
}

// ListObjectsV2 mocks base method.
func (m *MockS3) ListObjectsV2(arg0 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectsV2", arg0)
	ret0, _ := ret[0].(*s3.ListObjectsV2Output)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsV2 indicates an expected call of ListObjectsV2.
func (mr *MockS3MockRecorder) ListObjectsV2(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2", reflect.TypeOf((*MockS3)(nil).ListObjectsV2), arg0)
}

// ListObjectsV2AsList mocks base method.
func (m *MockS3) ListObjectsV2AsList(arg0 context.Context, arg1 *s3.ListObjectsV2Input) ([]*s3.Object, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectsV2AsList", arg0, arg1)
	ret0, _ := ret[0].([]*s3.Object)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsV2AsList indicates an expected call of ListObjectsV2AsList.
func (mr *MockS3MockRecorder) ListObjectsV2AsList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2AsList", reflect.TypeOf((*MockS3)(nil).ListObjectsV2AsList), arg0, arg1)
}

// ListObjectsV2Pages mocks base method.
func (m *MockS3) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.ListObjectsV2Output, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectsV2Pages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages.
func (mr *MockS3MockRecorder) ListObjectsV2Pages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Pages", reflect.TypeOf((*MockS3)(nil).ListObjectsV2Pages), arg0, arg1)
}

// ListObjectsV2PagesWithContext mocks base method.
func (m *MockS3) ListObjectsV2PagesWithContext(arg0 context.Context, arg1 *s3.ListObjectsV2Input, arg2 func(*s3.ListObjectsV2Output, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsV2PagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListObjectsV2PagesWithContext indicates an expected call of ListObjectsV2PagesWithContext.
func (mr *MockS3MockRecorder) ListObjectsV2PagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2PagesWithContext", reflect.TypeOf((*MockS3)(nil).ListObjectsV2PagesWithContext), varargs...)
}

// ListObjectsV2Request mocks base method.
func (m *MockS3) ListObjectsV2Request(arg0 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectsV2Request", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListObjectsV2Output)
	return ret0, ret1
}

// ListObjectsV2Request indicates an expected call of ListObjectsV2Request.
func (mr *MockS3MockRecorder) ListObjectsV2Request(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Request", reflect.TypeOf((*MockS3)(nil).ListObjectsV2Request), arg0)
}

// ListObjectsV2WithContext mocks base method.
func (m *MockS3) ListObjectsV2WithContext(arg0 context.Context, arg1 *s3.ListObjectsV2Input, arg2 ...request.Option) (*s3.ListObjectsV2Output, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsV2WithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListObjectsV2Output)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsV2WithContext indicates an expected call of ListObjectsV2WithContext.
func (mr *MockS3MockRecorder) ListObjectsV2WithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2WithContext", reflect.TypeOf((*MockS3)(nil).ListObjectsV2WithContext), varargs...)
}

// ListObjectsWithContext mocks base method.
func (m *MockS3) ListObjectsWithContext(arg0 context.Context, arg1 *s3.ListObjectsInput, arg2 ...request.Option) (*s3.ListObjectsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsWithContext indicates an expected call of ListObjectsWithContext.
func (mr *MockS3MockRecorder) ListObjectsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsWithContext", reflect.TypeOf((*MockS3)(nil).ListObjectsWithContext), varargs...)
}

// ListParts mocks base method.
func (m *MockS3) ListParts(arg0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListParts", arg0)
	ret0, _ := ret[0].(*s3.ListPartsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListParts indicates an expected call of ListParts.
func (mr *MockS3MockRecorder) ListParts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListParts", reflect.TypeOf((*MockS3)(nil).ListParts), arg0)
}

// ListPartsPages mocks base method.
func (m *MockS3) ListPartsPages(arg0 *s3.ListPartsInput, arg1 func(*s3.ListPartsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPartsPages indicates an expected call of ListPartsPages.
func (mr *MockS3MockRecorder) ListPartsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsPages", reflect.TypeOf((*MockS3)(nil).ListPartsPages), arg0, arg1)
}

// ListPartsPagesWithContext mocks base method.
func (m *MockS3) ListPartsPagesWithContext(arg0 context.Context, arg1 *s3.ListPartsInput, arg2 func(*s3.ListPartsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPartsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPartsPagesWithContext indicates an expected call of ListPartsPagesWithContext.
func (mr *MockS3MockRecorder) ListPartsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsPagesWithContext", reflect.TypeOf((*MockS3)(nil).ListPartsPagesWithContext), varargs...)
}

// ListPartsRequest mocks base method.
func (m *MockS3) ListPartsRequest(arg0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.ListPartsOutput)
	return ret0, ret1
}

// ListPartsRequest indicates an expected call of ListPartsRequest.
func (mr *MockS3MockRecorder) ListPartsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsRequest", reflect.TypeOf((*MockS3)(nil).ListPartsRequest), arg0)
}

// ListPartsWithContext mocks base method.
func (m *MockS3) ListPartsWithContext(arg0 context.Context, arg1 *s3.ListPartsInput, arg2 ...request.Option) (*s3.ListPartsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPartsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.ListPartsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPartsWithContext indicates an expected call of ListPartsWithContext.
func (mr *MockS3MockRecorder) ListPartsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsWithContext", reflect.TypeOf((*MockS3)(nil).ListPartsWithContext), varargs...)
}

// PutBucketAccelerateConfiguration mocks base method.
func (m *MockS3) PutBucketAccelerateConfiguration(arg0 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketAccelerateConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketAccelerateConfiguration indicates an expected call of PutBucketAccelerateConfiguration.
func (mr *MockS3MockRecorder) PutBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketAccelerateConfiguration), arg0)
}

// PutBucketAccelerateConfigurationRequest mocks base method.
func (m *MockS3) PutBucketAccelerateConfigurationRequest(arg0 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketAccelerateConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketAccelerateConfigurationOutput)
	return ret0, ret1
}

// PutBucketAccelerateConfigurationRequest indicates an expected call of PutBucketAccelerateConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketAccelerateConfigurationRequest), arg0)
}

// PutBucketAccelerateConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketAccelerateConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketAccelerateConfigurationInput, arg2 ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketAccelerateConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketAccelerateConfigurationWithContext indicates an expected call of PutBucketAccelerateConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketAccelerateConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketAccelerateConfigurationWithContext), varargs...)
}

// PutBucketAcl mocks base method.
func (m *MockS3) PutBucketAcl(arg0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketAcl", arg0)
	ret0, _ := ret[0].(*s3.PutBucketAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketAcl indicates an expected call of PutBucketAcl.
func (mr *MockS3MockRecorder) PutBucketAcl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAcl", reflect.TypeOf((*MockS3)(nil).PutBucketAcl), arg0)
}

// PutBucketAclRequest mocks base method.
func (m *MockS3) PutBucketAclRequest(arg0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketAclRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketAclOutput)
	return ret0, ret1
}

// PutBucketAclRequest indicates an expected call of PutBucketAclRequest.
func (mr *MockS3MockRecorder) PutBucketAclRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAclRequest", reflect.TypeOf((*MockS3)(nil).PutBucketAclRequest), arg0)
}

// PutBucketAclWithContext mocks base method.
func (m *MockS3) PutBucketAclWithContext(arg0 context.Context, arg1 *s3.PutBucketAclInput, arg2 ...request.Option) (*s3.PutBucketAclOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketAclWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketAclWithContext indicates an expected call of PutBucketAclWithContext.
func (mr *MockS3MockRecorder) PutBucketAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAclWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketAclWithContext), varargs...)
}

// PutBucketAnalyticsConfiguration mocks base method.
func (m *MockS3) PutBucketAnalyticsConfiguration(arg0 *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketAnalyticsConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketAnalyticsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketAnalyticsConfiguration indicates an expected call of PutBucketAnalyticsConfiguration.
func (mr *MockS3MockRecorder) PutBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketAnalyticsConfiguration), arg0)
}

// PutBucketAnalyticsConfigurationRequest mocks base method.
func (m *MockS3) PutBucketAnalyticsConfigurationRequest(arg0 *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketAnalyticsConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketAnalyticsConfigurationOutput)
	return ret0, ret1
}

// PutBucketAnalyticsConfigurationRequest indicates an expected call of PutBucketAnalyticsConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketAnalyticsConfigurationRequest), arg0)
}

// PutBucketAnalyticsConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketAnalyticsConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketAnalyticsConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketAnalyticsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketAnalyticsConfigurationWithContext indicates an expected call of PutBucketAnalyticsConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketAnalyticsConfigurationWithContext), varargs...)
}

// PutBucketCors mocks base method.
func (m *MockS3) PutBucketCors(arg0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketCors", arg0)
	ret0, _ := ret[0].(*s3.PutBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketCors indicates an expected call of PutBucketCors.
func (mr *MockS3MockRecorder) PutBucketCors(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCors", reflect.TypeOf((*MockS3)(nil).PutBucketCors), arg0)
}

// PutBucketCorsRequest mocks base method.
func (m *MockS3) PutBucketCorsRequest(arg0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketCorsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketCorsOutput)
	return ret0, ret1
}

// PutBucketCorsRequest indicates an expected call of PutBucketCorsRequest.
func (mr *MockS3MockRecorder) PutBucketCorsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCorsRequest", reflect.TypeOf((*MockS3)(nil).PutBucketCorsRequest), arg0)
}

// PutBucketCorsWithContext mocks base method.
func (m *MockS3) PutBucketCorsWithContext(arg0 context.Context, arg1 *s3.PutBucketCorsInput, arg2 ...request.Option) (*s3.PutBucketCorsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketCorsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketCorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketCorsWithContext indicates an expected call of PutBucketCorsWithContext.
func (mr *MockS3MockRecorder) PutBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCorsWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketCorsWithContext), varargs...)
}

// PutBucketEncryption mocks base method.
func (m *MockS3) PutBucketEncryption(arg0 *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketEncryption", arg0)
	ret0, _ := ret[0].(*s3.PutBucketEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketEncryption indicates an expected call of PutBucketEncryption.
func (mr *MockS3MockRecorder) PutBucketEncryption(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryption", reflect.TypeOf((*MockS3)(nil).PutBucketEncryption), arg0)
}

// PutBucketEncryptionRequest mocks base method.
func (m *MockS3) PutBucketEncryptionRequest(arg0 *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketEncryptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketEncryptionOutput)
	return ret0, ret1
}

// PutBucketEncryptionRequest indicates an expected call of PutBucketEncryptionRequest.
func (mr *MockS3MockRecorder) PutBucketEncryptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryptionRequest", reflect.TypeOf((*MockS3)(nil).PutBucketEncryptionRequest), arg0)
}

// PutBucketEncryptionWithContext mocks base method.
func (m *MockS3) PutBucketEncryptionWithContext(arg0 context.Context, arg1 *s3.PutBucketEncryptionInput, arg2 ...request.Option) (*s3.PutBucketEncryptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketEncryptionWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketEncryptionWithContext indicates an expected call of PutBucketEncryptionWithContext.
func (mr *MockS3MockRecorder) PutBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryptionWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketEncryptionWithContext), varargs...)
}

// PutBucketIntelligentTieringConfiguration mocks base method.
func (m *MockS3) PutBucketIntelligentTieringConfiguration(arg0 *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketIntelligentTieringConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketIntelligentTieringConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketIntelligentTieringConfiguration indicates an expected call of PutBucketIntelligentTieringConfiguration.
func (mr *MockS3MockRecorder) PutBucketIntelligentTieringConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketIntelligentTieringConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketIntelligentTieringConfiguration), arg0)
}

// PutBucketIntelligentTieringConfigurationRequest mocks base method.
func (m *MockS3) PutBucketIntelligentTieringConfigurationRequest(arg0 *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketIntelligentTieringConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketIntelligentTieringConfigurationOutput)
	return ret0, ret1
}

// PutBucketIntelligentTieringConfigurationRequest indicates an expected call of PutBucketIntelligentTieringConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketIntelligentTieringConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketIntelligentTieringConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketIntelligentTieringConfigurationRequest), arg0)
}

// PutBucketIntelligentTieringConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketIntelligentTieringConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketIntelligentTieringConfigurationInput, arg2 ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketIntelligentTieringConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketIntelligentTieringConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketIntelligentTieringConfigurationWithContext indicates an expected call of PutBucketIntelligentTieringConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketIntelligentTieringConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketIntelligentTieringConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketIntelligentTieringConfigurationWithContext), varargs...)
}

// PutBucketInventoryConfiguration mocks base method.
func (m *MockS3) PutBucketInventoryConfiguration(arg0 *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketInventoryConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketInventoryConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketInventoryConfiguration indicates an expected call of PutBucketInventoryConfiguration.
func (mr *MockS3MockRecorder) PutBucketInventoryConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketInventoryConfiguration), arg0)
}

// PutBucketInventoryConfigurationRequest mocks base method.
func (m *MockS3) PutBucketInventoryConfigurationRequest(arg0 *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketInventoryConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketInventoryConfigurationOutput)
	return ret0, ret1
}

// PutBucketInventoryConfigurationRequest indicates an expected call of PutBucketInventoryConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketInventoryConfigurationRequest), arg0)
}

// PutBucketInventoryConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketInventoryConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketInventoryConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketInventoryConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketInventoryConfigurationWithContext indicates an expected call of PutBucketInventoryConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketInventoryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketInventoryConfigurationWithContext), varargs...)
}

// PutBucketLifecycle mocks base method.
func (m *MockS3) PutBucketLifecycle(arg0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketLifecycle", arg0)
	ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketLifecycle indicates an expected call of PutBucketLifecycle.
func (mr *MockS3MockRecorder) PutBucketLifecycle(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycle", reflect.TypeOf((*MockS3)(nil).PutBucketLifecycle), arg0)
}

// PutBucketLifecycleConfiguration mocks base method.
func (m *MockS3) PutBucketLifecycleConfiguration(arg0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketLifecycleConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketLifecycleConfiguration indicates an expected call of PutBucketLifecycleConfiguration.
func (mr *MockS3MockRecorder) PutBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketLifecycleConfiguration), arg0)
}

// PutBucketLifecycleConfigurationRequest mocks base method.
func (m *MockS3) PutBucketLifecycleConfigurationRequest(arg0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketLifecycleConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketLifecycleConfigurationOutput)
	return ret0, ret1
}

// PutBucketLifecycleConfigurationRequest indicates an expected call of PutBucketLifecycleConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketLifecycleConfigurationRequest), arg0)
}

// PutBucketLifecycleConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketLifecycleConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketLifecycleConfigurationInput, arg2 ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketLifecycleConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketLifecycleConfigurationWithContext indicates an expected call of PutBucketLifecycleConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketLifecycleConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketLifecycleConfigurationWithContext), varargs...)
}

// PutBucketLifecycleRequest mocks base method.
func (m *MockS3) PutBucketLifecycleRequest(arg0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketLifecycleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketLifecycleOutput)
	return ret0, ret1
}

// PutBucketLifecycleRequest indicates an expected call of PutBucketLifecycleRequest.
func (mr *MockS3MockRecorder) PutBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleRequest", reflect.TypeOf((*MockS3)(nil).PutBucketLifecycleRequest), arg0)
}

// PutBucketLifecycleWithContext mocks base method.
func (m *MockS3) PutBucketLifecycleWithContext(arg0 context.Context, arg1 *s3.PutBucketLifecycleInput, arg2 ...request.Option) (*s3.PutBucketLifecycleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketLifecycleWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketLifecycleWithContext indicates an expected call of PutBucketLifecycleWithContext.
func (mr *MockS3MockRecorder) PutBucketLifecycleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketLifecycleWithContext), varargs...)
}

// PutBucketLogging mocks base method.
func (m *MockS3) PutBucketLogging(arg0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketLogging", arg0)
	ret0, _ := ret[0].(*s3.PutBucketLoggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketLogging indicates an expected call of PutBucketLogging.
func (mr *MockS3MockRecorder) PutBucketLogging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLogging", reflect.TypeOf((*MockS3)(nil).PutBucketLogging), arg0)
}

// PutBucketLoggingRequest mocks base method.
func (m *MockS3) PutBucketLoggingRequest(arg0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketLoggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketLoggingOutput)
	return ret0, ret1
}

// PutBucketLoggingRequest indicates an expected call of PutBucketLoggingRequest.
func (mr *MockS3MockRecorder) PutBucketLoggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLoggingRequest", reflect.TypeOf((*MockS3)(nil).PutBucketLoggingRequest), arg0)
}

// PutBucketLoggingWithContext mocks base method.
func (m *MockS3) PutBucketLoggingWithContext(arg0 context.Context, arg1 *s3.PutBucketLoggingInput, arg2 ...request.Option) (*s3.PutBucketLoggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketLoggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketLoggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketLoggingWithContext indicates an expected call of PutBucketLoggingWithContext.
func (mr *MockS3MockRecorder) PutBucketLoggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLoggingWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketLoggingWithContext), varargs...)
}

// PutBucketMetricsConfiguration mocks base method.
func (m *MockS3) PutBucketMetricsConfiguration(arg0 *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketMetricsConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketMetricsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketMetricsConfiguration indicates an expected call of PutBucketMetricsConfiguration.
func (mr *MockS3MockRecorder) PutBucketMetricsConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketMetricsConfiguration), arg0)
}

// PutBucketMetricsConfigurationRequest mocks base method.
func (m *MockS3) PutBucketMetricsConfigurationRequest(arg0 *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketMetricsConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketMetricsConfigurationOutput)
	return ret0, ret1
}

// PutBucketMetricsConfigurationRequest indicates an expected call of PutBucketMetricsConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketMetricsConfigurationRequest), arg0)
}

// PutBucketMetricsConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketMetricsConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketMetricsConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketMetricsConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketMetricsConfigurationWithContext indicates an expected call of PutBucketMetricsConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketMetricsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketMetricsConfigurationWithContext), varargs...)
}

// PutBucketNotification mocks base method.
func (m *MockS3) PutBucketNotification(arg0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketNotification", arg0)
	ret0, _ := ret[0].(*s3.PutBucketNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketNotification indicates an expected call of PutBucketNotification.
func (mr *MockS3MockRecorder) PutBucketNotification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotification", reflect.TypeOf((*MockS3)(nil).PutBucketNotification), arg0)
}

// PutBucketNotificationConfiguration mocks base method.
func (m *MockS3) PutBucketNotificationConfiguration(arg0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketNotificationConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketNotificationConfiguration indicates an expected call of PutBucketNotificationConfiguration.
func (mr *MockS3MockRecorder) PutBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfiguration", reflect.TypeOf((*MockS3)(nil).PutBucketNotificationConfiguration), arg0)
}

// PutBucketNotificationConfigurationRequest mocks base method.
func (m *MockS3) PutBucketNotificationConfigurationRequest(arg0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketNotificationConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketNotificationConfigurationOutput)
	return ret0, ret1
}

// PutBucketNotificationConfigurationRequest indicates an expected call of PutBucketNotificationConfigurationRequest.
func (mr *MockS3MockRecorder) PutBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketNotificationConfigurationRequest), arg0)
}

// PutBucketNotificationConfigurationWithContext mocks base method.
func (m *MockS3) PutBucketNotificationConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketNotificationConfigurationInput, arg2 ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketNotificationConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketNotificationConfigurationWithContext indicates an expected call of PutBucketNotificationConfigurationWithContext.
func (mr *MockS3MockRecorder) PutBucketNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketNotificationConfigurationWithContext), varargs...)
}

// PutBucketNotificationRequest mocks base method.
func (m *MockS3) PutBucketNotificationRequest(arg0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketNotificationOutput)
	return ret0, ret1
}

// PutBucketNotificationRequest indicates an expected call of PutBucketNotificationRequest.
func (mr *MockS3MockRecorder) PutBucketNotificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketNotificationRequest), arg0)
}

// PutBucketNotificationWithContext mocks base method.
func (m *MockS3) PutBucketNotificationWithContext(arg0 context.Context, arg1 *s3.PutBucketNotificationInput, arg2 ...request.Option) (*s3.PutBucketNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketNotificationWithContext indicates an expected call of PutBucketNotificationWithContext.
func (mr *MockS3MockRecorder) PutBucketNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketNotificationWithContext), varargs...)
}

// PutBucketOwnershipControls mocks base method.
func (m *MockS3) PutBucketOwnershipControls(arg0 *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketOwnershipControls", arg0)
	ret0, _ := ret[0].(*s3.PutBucketOwnershipControlsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketOwnershipControls indicates an expected call of PutBucketOwnershipControls.
func (mr *MockS3MockRecorder) PutBucketOwnershipControls(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketOwnershipControls", reflect.TypeOf((*MockS3)(nil).PutBucketOwnershipControls), arg0)
}

// PutBucketOwnershipControlsRequest mocks base method.
func (m *MockS3) PutBucketOwnershipControlsRequest(arg0 *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketOwnershipControlsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketOwnershipControlsOutput)
	return ret0, ret1
}

// PutBucketOwnershipControlsRequest indicates an expected call of PutBucketOwnershipControlsRequest.
func (mr *MockS3MockRecorder) PutBucketOwnershipControlsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketOwnershipControlsRequest", reflect.TypeOf((*MockS3)(nil).PutBucketOwnershipControlsRequest), arg0)
}

// PutBucketOwnershipControlsWithContext mocks base method.
func (m *MockS3) PutBucketOwnershipControlsWithContext(arg0 context.Context, arg1 *s3.PutBucketOwnershipControlsInput, arg2 ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketOwnershipControlsWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketOwnershipControlsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketOwnershipControlsWithContext indicates an expected call of PutBucketOwnershipControlsWithContext.
func (mr *MockS3MockRecorder) PutBucketOwnershipControlsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketOwnershipControlsWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketOwnershipControlsWithContext), varargs...)
}

// PutBucketPolicy mocks base method.
func (m *MockS3) PutBucketPolicy(arg0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketPolicy", arg0)
	ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketPolicy indicates an expected call of PutBucketPolicy.
func (mr *MockS3MockRecorder) PutBucketPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicy", reflect.TypeOf((*MockS3)(nil).PutBucketPolicy), arg0)
}

// PutBucketPolicyRequest mocks base method.
func (m *MockS3) PutBucketPolicyRequest(arg0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketPolicyOutput)
	return ret0, ret1
}

// PutBucketPolicyRequest indicates an expected call of PutBucketPolicyRequest.
func (mr *MockS3MockRecorder) PutBucketPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicyRequest", reflect.TypeOf((*MockS3)(nil).PutBucketPolicyRequest), arg0)
}

// PutBucketPolicyWithContext mocks base method.
func (m *MockS3) PutBucketPolicyWithContext(arg0 context.Context, arg1 *s3.PutBucketPolicyInput, arg2 ...request.Option) (*s3.PutBucketPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketPolicyWithContext indicates an expected call of PutBucketPolicyWithContext.
func (mr *MockS3MockRecorder) PutBucketPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicyWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketPolicyWithContext), varargs...)
}

// PutBucketReplication mocks base method.
func (m *MockS3) PutBucketReplication(arg0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketReplication", arg0)
	ret0, _ := ret[0].(*s3.PutBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketReplication indicates an expected call of PutBucketReplication.
func (mr *MockS3MockRecorder) PutBucketReplication(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplication", reflect.TypeOf((*MockS3)(nil).PutBucketReplication), arg0)
}

// PutBucketReplicationRequest mocks base method.
func (m *MockS3) PutBucketReplicationRequest(arg0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketReplicationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketReplicationOutput)
	return ret0, ret1
}

// PutBucketReplicationRequest indicates an expected call of PutBucketReplicationRequest.
func (mr *MockS3MockRecorder) PutBucketReplicationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplicationRequest", reflect.TypeOf((*MockS3)(nil).PutBucketReplicationRequest), arg0)
}

// PutBucketReplicationWithContext mocks base method.
func (m *MockS3) PutBucketReplicationWithContext(arg0 context.Context, arg1 *s3.PutBucketReplicationInput, arg2 ...request.Option) (*s3.PutBucketReplicationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketReplicationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketReplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketReplicationWithContext indicates an expected call of PutBucketReplicationWithContext.
func (mr *MockS3MockRecorder) PutBucketReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplicationWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketReplicationWithContext), varargs...)
}

// PutBucketRequestPayment mocks base method.
func (m *MockS3) PutBucketRequestPayment(arg0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketRequestPayment", arg0)
	ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketRequestPayment indicates an expected call of PutBucketRequestPayment.
func (mr *MockS3MockRecorder) PutBucketRequestPayment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPayment", reflect.TypeOf((*MockS3)(nil).PutBucketRequestPayment), arg0)
}

// PutBucketRequestPaymentRequest mocks base method.
func (m *MockS3) PutBucketRequestPaymentRequest(arg0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketRequestPaymentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketRequestPaymentOutput)
	return ret0, ret1
}

// PutBucketRequestPaymentRequest indicates an expected call of PutBucketRequestPaymentRequest.
func (mr *MockS3MockRecorder) PutBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPaymentRequest", reflect.TypeOf((*MockS3)(nil).PutBucketRequestPaymentRequest), arg0)
}

// PutBucketRequestPaymentWithContext mocks base method.
func (m *MockS3) PutBucketRequestPaymentWithContext(arg0 context.Context, arg1 *s3.PutBucketRequestPaymentInput, arg2 ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketRequestPaymentWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketRequestPaymentWithContext indicates an expected call of PutBucketRequestPaymentWithContext.
func (mr *MockS3MockRecorder) PutBucketRequestPaymentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPaymentWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketRequestPaymentWithContext), varargs...)
}

// PutBucketTagging mocks base method.
func (m *MockS3) PutBucketTagging(arg0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketTagging", arg0)
	ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketTagging indicates an expected call of PutBucketTagging.
func (mr *MockS3MockRecorder) PutBucketTagging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTagging", reflect.TypeOf((*MockS3)(nil).PutBucketTagging), arg0)
}

// PutBucketTaggingRequest mocks base method.
func (m *MockS3) PutBucketTaggingRequest(arg0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketTaggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketTaggingOutput)
	return ret0, ret1
}

// PutBucketTaggingRequest indicates an expected call of PutBucketTaggingRequest.
func (mr *MockS3MockRecorder) PutBucketTaggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTaggingRequest", reflect.TypeOf((*MockS3)(nil).PutBucketTaggingRequest), arg0)
}

// PutBucketTaggingWithContext mocks base method.
func (m *MockS3) PutBucketTaggingWithContext(arg0 context.Context, arg1 *s3.PutBucketTaggingInput, arg2 ...request.Option) (*s3.PutBucketTaggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketTaggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketTaggingWithContext indicates an expected call of PutBucketTaggingWithContext.
func (mr *MockS3MockRecorder) PutBucketTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTaggingWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketTaggingWithContext), varargs...)
}

// PutBucketVersioning mocks base method.
func (m *MockS3) PutBucketVersioning(arg0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketVersioning", arg0)
	ret0, _ := ret[0].(*s3.PutBucketVersioningOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketVersioning indicates an expected call of PutBucketVersioning.
func (mr *MockS3MockRecorder) PutBucketVersioning(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioning", reflect.TypeOf((*MockS3)(nil).PutBucketVersioning), arg0)
}

// PutBucketVersioningRequest mocks base method.
func (m *MockS3) PutBucketVersioningRequest(arg0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketVersioningRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketVersioningOutput)
	return ret0, ret1
}

// PutBucketVersioningRequest indicates an expected call of PutBucketVersioningRequest.
func (mr *MockS3MockRecorder) PutBucketVersioningRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioningRequest", reflect.TypeOf((*MockS3)(nil).PutBucketVersioningRequest), arg0)
}

// PutBucketVersioningWithContext mocks base method.
func (m *MockS3) PutBucketVersioningWithContext(arg0 context.Context, arg1 *s3.PutBucketVersioningInput, arg2 ...request.Option) (*s3.PutBucketVersioningOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketVersioningWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketVersioningOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketVersioningWithContext indicates an expected call of PutBucketVersioningWithContext.
func (mr *MockS3MockRecorder) PutBucketVersioningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioningWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketVersioningWithContext), varargs...)
}

// PutBucketWebsite mocks base method.
func (m *MockS3) PutBucketWebsite(arg0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketWebsite", arg0)
	ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketWebsite indicates an expected call of PutBucketWebsite.
func (mr *MockS3MockRecorder) PutBucketWebsite(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsite", reflect.TypeOf((*MockS3)(nil).PutBucketWebsite), arg0)
}

// PutBucketWebsiteRequest mocks base method.
func (m *MockS3) PutBucketWebsiteRequest(arg0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBucketWebsiteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutBucketWebsiteOutput)
	return ret0, ret1
}

// PutBucketWebsiteRequest indicates an expected call of PutBucketWebsiteRequest.
func (mr *MockS3MockRecorder) PutBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsiteRequest", reflect.TypeOf((*MockS3)(nil).PutBucketWebsiteRequest), arg0)
}

// PutBucketWebsiteWithContext mocks base method.
func (m *MockS3) PutBucketWebsiteWithContext(arg0 context.Context, arg1 *s3.PutBucketWebsiteInput, arg2 ...request.Option) (*s3.PutBucketWebsiteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutBucketWebsiteWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutBucketWebsiteWithContext indicates an expected call of PutBucketWebsiteWithContext.
func (mr *MockS3MockRecorder) PutBucketWebsiteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsiteWithContext", reflect.TypeOf((*MockS3)(nil).PutBucketWebsiteWithContext), varargs...)
}

// PutObject mocks base method.
func (m *MockS3) PutObject(arg0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObject", arg0)
	ret0, _ := ret[0].(*s3.PutObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObject indicates an expected call of PutObject.
func (mr *MockS3MockRecorder) PutObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockS3)(nil).PutObject), arg0)
}

// PutObjectAcl mocks base method.
func (m *MockS3) PutObjectAcl(arg0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectAcl", arg0)
	ret0, _ := ret[0].(*s3.PutObjectAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectAcl indicates an expected call of PutObjectAcl.
func (mr *MockS3MockRecorder) PutObjectAcl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAcl", reflect.TypeOf((*MockS3)(nil).PutObjectAcl), arg0)
}

// PutObjectAclRequest mocks base method.
func (m *MockS3) PutObjectAclRequest(arg0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectAclRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectAclOutput)
	return ret0, ret1
}

// PutObjectAclRequest indicates an expected call of PutObjectAclRequest.
func (mr *MockS3MockRecorder) PutObjectAclRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAclRequest", reflect.TypeOf((*MockS3)(nil).PutObjectAclRequest), arg0)
}

// PutObjectAclWithContext mocks base method.
func (m *MockS3) PutObjectAclWithContext(arg0 context.Context, arg1 *s3.PutObjectAclInput, arg2 ...request.Option) (*s3.PutObjectAclOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObjectAclWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectAclWithContext indicates an expected call of PutObjectAclWithContext.
func (mr *MockS3MockRecorder) PutObjectAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAclWithContext", reflect.TypeOf((*MockS3)(nil).PutObjectAclWithContext), varargs...)
}

// PutObjectLegalHold mocks base method.
func (m *MockS3) PutObjectLegalHold(arg0 *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectLegalHold", arg0)
	ret0, _ := ret[0].(*s3.PutObjectLegalHoldOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectLegalHold indicates an expected call of PutObjectLegalHold.
func (mr *MockS3MockRecorder) PutObjectLegalHold(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLegalHold", reflect.TypeOf((*MockS3)(nil).PutObjectLegalHold), arg0)
}

// PutObjectLegalHoldRequest mocks base method.
func (m *MockS3) PutObjectLegalHoldRequest(arg0 *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectLegalHoldRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectLegalHoldOutput)
	return ret0, ret1
}

// PutObjectLegalHoldRequest indicates an expected call of PutObjectLegalHoldRequest.
func (mr *MockS3MockRecorder) PutObjectLegalHoldRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLegalHoldRequest", reflect.TypeOf((*MockS3)(nil).PutObjectLegalHoldRequest), arg0)
}

// PutObjectLegalHoldWithContext mocks base method.
func (m *MockS3) PutObjectLegalHoldWithContext(arg0 context.Context, arg1 *s3.PutObjectLegalHoldInput, arg2 ...request.Option) (*s3.PutObjectLegalHoldOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObjectLegalHoldWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectLegalHoldOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectLegalHoldWithContext indicates an expected call of PutObjectLegalHoldWithContext.
func (mr *MockS3MockRecorder) PutObjectLegalHoldWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLegalHoldWithContext", reflect.TypeOf((*MockS3)(nil).PutObjectLegalHoldWithContext), varargs...)
}

// PutObjectLockConfiguration mocks base method.
func (m *MockS3) PutObjectLockConfiguration(arg0 *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectLockConfiguration", arg0)
	ret0, _ := ret[0].(*s3.PutObjectLockConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectLockConfiguration indicates an expected call of PutObjectLockConfiguration.
func (mr *MockS3MockRecorder) PutObjectLockConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLockConfiguration", reflect.TypeOf((*MockS3)(nil).PutObjectLockConfiguration), arg0)
}

// PutObjectLockConfigurationRequest mocks base method.
func (m *MockS3) PutObjectLockConfigurationRequest(arg0 *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectLockConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectLockConfigurationOutput)
	return ret0, ret1
}

// PutObjectLockConfigurationRequest indicates an expected call of PutObjectLockConfigurationRequest.
func (mr *MockS3MockRecorder) PutObjectLockConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLockConfigurationRequest", reflect.TypeOf((*MockS3)(nil).PutObjectLockConfigurationRequest), arg0)
}

// PutObjectLockConfigurationWithContext mocks base method.
func (m *MockS3) PutObjectLockConfigurationWithContext(arg0 context.Context, arg1 *s3.PutObjectLockConfigurationInput, arg2 ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObjectLockConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectLockConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectLockConfigurationWithContext indicates an expected call of PutObjectLockConfigurationWithContext.
func (mr *MockS3MockRecorder) PutObjectLockConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLockConfigurationWithContext", reflect.TypeOf((*MockS3)(nil).PutObjectLockConfigurationWithContext), varargs...)
}

// PutObjectRequest mocks base method.
func (m *MockS3) PutObjectRequest(arg0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectOutput)
	return ret0, ret1
}

// PutObjectRequest indicates an expected call of PutObjectRequest.
func (mr *MockS3MockRecorder) PutObjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRequest", reflect.TypeOf((*MockS3)(nil).PutObjectRequest), arg0)
}

// PutObjectRetention mocks base method.
func (m *MockS3) PutObjectRetention(arg0 *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectRetention", arg0)
	ret0, _ := ret[0].(*s3.PutObjectRetentionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectRetention indicates an expected call of PutObjectRetention.
func (mr *MockS3MockRecorder) PutObjectRetention(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRetention", reflect.TypeOf((*MockS3)(nil).PutObjectRetention), arg0)
}

// PutObjectRetentionRequest mocks base method.
func (m *MockS3) PutObjectRetentionRequest(arg0 *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectRetentionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectRetentionOutput)
	return ret0, ret1
}

// PutObjectRetentionRequest indicates an expected call of PutObjectRetentionRequest.
func (mr *MockS3MockRecorder) PutObjectRetentionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRetentionRequest", reflect.TypeOf((*MockS3)(nil).PutObjectRetentionRequest), arg0)
}

// PutObjectRetentionWithContext mocks base method.
func (m *MockS3) PutObjectRetentionWithContext(arg0 context.Context, arg1 *s3.PutObjectRetentionInput, arg2 ...request.Option) (*s3.PutObjectRetentionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObjectRetentionWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectRetentionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectRetentionWithContext indicates an expected call of PutObjectRetentionWithContext.
func (mr *MockS3MockRecorder) PutObjectRetentionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRetentionWithContext", reflect.TypeOf((*MockS3)(nil).PutObjectRetentionWithContext), varargs...)
}

// PutObjectTagging mocks base method.
func (m *MockS3) PutObjectTagging(arg0 *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectTagging", arg0)
	ret0, _ := ret[0].(*s3.PutObjectTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectTagging indicates an expected call of PutObjectTagging.
func (mr *MockS3MockRecorder) PutObjectTagging(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTagging", reflect.TypeOf((*MockS3)(nil).PutObjectTagging), arg0)
}

// PutObjectTaggingRequest mocks base method.
func (m *MockS3) PutObjectTaggingRequest(arg0 *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutObjectTaggingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutObjectTaggingOutput)
	return ret0, ret1
}

// PutObjectTaggingRequest indicates an expected call of PutObjectTaggingRequest.
func (mr *MockS3MockRecorder) PutObjectTaggingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTaggingRequest", reflect.TypeOf((*MockS3)(nil).PutObjectTaggingRequest), arg0)
}

// PutObjectTaggingWithContext mocks base method.
func (m *MockS3) PutObjectTaggingWithContext(arg0 context.Context, arg1 *s3.PutObjectTaggingInput, arg2 ...request.Option) (*s3.PutObjectTaggingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObjectTaggingWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectTaggingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectTaggingWithContext indicates an expected call of PutObjectTaggingWithContext.
func (mr *MockS3MockRecorder) PutObjectTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTaggingWithContext", reflect.TypeOf((*MockS3)(nil).PutObjectTaggingWithContext), varargs...)
}

// PutObjectWithContext mocks base method.
func (m *MockS3) PutObjectWithContext(arg0 context.Context, arg1 *s3.PutObjectInput, arg2 ...request.Option) (*s3.PutObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObjectWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectWithContext indicates an expected call of PutObjectWithContext.
func (mr *MockS3MockRecorder) PutObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectWithContext", reflect.TypeOf((*MockS3)(nil).PutObjectWithContext), varargs...)
}

// PutPublicAccessBlock mocks base method.
func (m *MockS3) PutPublicAccessBlock(arg0 *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPublicAccessBlock", arg0)
	ret0, _ := ret[0].(*s3.PutPublicAccessBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutPublicAccessBlock indicates an expected call of PutPublicAccessBlock.
func (mr *MockS3MockRecorder) PutPublicAccessBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPublicAccessBlock", reflect.TypeOf((*MockS3)(nil).PutPublicAccessBlock), arg0)
}

// PutPublicAccessBlockRequest mocks base method.
func (m *MockS3) PutPublicAccessBlockRequest(arg0 *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPublicAccessBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.PutPublicAccessBlockOutput)
	return ret0, ret1
}

// PutPublicAccessBlockRequest indicates an expected call of PutPublicAccessBlockRequest.
func (mr *MockS3MockRecorder) PutPublicAccessBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPublicAccessBlockRequest", reflect.TypeOf((*MockS3)(nil).PutPublicAccessBlockRequest), arg0)
}

// PutPublicAccessBlockWithContext mocks base method.
func (m *MockS3) PutPublicAccessBlockWithContext(arg0 context.Context, arg1 *s3.PutPublicAccessBlockInput, arg2 ...request.Option) (*s3.PutPublicAccessBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutPublicAccessBlockWithContext", varargs...)
	ret0, _ := ret[0].(*s3.PutPublicAccessBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutPublicAccessBlockWithContext indicates an expected call of PutPublicAccessBlockWithContext.
func (mr *MockS3MockRecorder) PutPublicAccessBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPublicAccessBlockWithContext", reflect.TypeOf((*MockS3)(nil).PutPublicAccessBlockWithContext), varargs...)
}

// RestoreObject mocks base method.
func (m *MockS3) RestoreObject(arg0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreObject", arg0)
	ret0, _ := ret[0].(*s3.RestoreObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreObject indicates an expected call of RestoreObject.
func (mr *MockS3MockRecorder) RestoreObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObject", reflect.TypeOf((*MockS3)(nil).RestoreObject), arg0)
}

// RestoreObjectRequest mocks base method.
func (m *MockS3) RestoreObjectRequest(arg0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreObjectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.RestoreObjectOutput)
	return ret0, ret1
}

// RestoreObjectRequest indicates an expected call of RestoreObjectRequest.
func (mr *MockS3MockRecorder) RestoreObjectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObjectRequest", reflect.TypeOf((*MockS3)(nil).RestoreObjectRequest), arg0)
}

// RestoreObjectWithContext mocks base method.
func (m *MockS3) RestoreObjectWithContext(arg0 context.Context, arg1 *s3.RestoreObjectInput, arg2 ...request.Option) (*s3.RestoreObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreObjectWithContext", varargs...)
	ret0, _ := ret[0].(*s3.RestoreObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreObjectWithContext indicates an expected call of RestoreObjectWithContext.
func (mr *MockS3MockRecorder) RestoreObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObjectWithContext", reflect.TypeOf((*MockS3)(nil).RestoreObjectWithContext), varargs...)
}

// SelectObjectContent mocks base method.
func (m *MockS3) SelectObjectContent(arg0 *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectObjectContent", arg0)
	ret0, _ := ret[0].(*s3.SelectObjectContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectObjectContent indicates an expected call of SelectObjectContent.
func (mr *MockS3MockRecorder) SelectObjectContent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContent", reflect.TypeOf((*MockS3)(nil).SelectObjectContent), arg0)
}

// SelectObjectContentRequest mocks base method.
func (m *MockS3) SelectObjectContentRequest(arg0 *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectObjectContentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.SelectObjectContentOutput)
	return ret0, ret1
}

// SelectObjectContentRequest indicates an expected call of SelectObjectContentRequest.
func (mr *MockS3MockRecorder) SelectObjectContentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContentRequest", reflect.TypeOf((*MockS3)(nil).SelectObjectContentRequest), arg0)
}

// SelectObjectContentWithContext mocks base method.
func (m *MockS3) SelectObjectContentWithContext(arg0 context.Context, arg1 *s3.SelectObjectContentInput, arg2 ...request.Option) (*s3.SelectObjectContentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SelectObjectContentWithContext", varargs...)
	ret0, _ := ret[0].(*s3.SelectObjectContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectObjectContentWithContext indicates an expected call of SelectObjectContentWithContext.
func (mr *MockS3MockRecorder) SelectObjectContentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContentWithContext", reflect.TypeOf((*MockS3)(nil).SelectObjectContentWithContext), varargs...)
}

// UploadPart mocks base method.
func (m *MockS3) UploadPart(arg0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPart", arg0)
	ret0, _ := ret[0].(*s3.UploadPartOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPart indicates an expected call of UploadPart.
func (mr *MockS3MockRecorder) UploadPart(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPart", reflect.TypeOf((*MockS3)(nil).UploadPart), arg0)
}

// UploadPartCopy mocks base method.
func (m *MockS3) UploadPartCopy(arg0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPartCopy", arg0)
	ret0, _ := ret[0].(*s3.UploadPartCopyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPartCopy indicates an expected call of UploadPartCopy.
func (mr *MockS3MockRecorder) UploadPartCopy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopy", reflect.TypeOf((*MockS3)(nil).UploadPartCopy), arg0)
}

// UploadPartCopyRequest mocks base method.
func (m *MockS3) UploadPartCopyRequest(arg0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPartCopyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.UploadPartCopyOutput)
	return ret0, ret1
}

// UploadPartCopyRequest indicates an expected call of UploadPartCopyRequest.
func (mr *MockS3MockRecorder) UploadPartCopyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopyRequest", reflect.TypeOf((*MockS3)(nil).UploadPartCopyRequest), arg0)
}

// UploadPartCopyWithContext mocks base method.
func (m *MockS3) UploadPartCopyWithContext(arg0 context.Context, arg1 *s3.UploadPartCopyInput, arg2 ...request.Option) (*s3.UploadPartCopyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadPartCopyWithContext", varargs...)
	ret0, _ := ret[0].(*s3.UploadPartCopyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPartCopyWithContext indicates an expected call of UploadPartCopyWithContext.
func (mr *MockS3MockRecorder) UploadPartCopyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopyWithContext", reflect.TypeOf((*MockS3)(nil).UploadPartCopyWithContext), varargs...)
}

// UploadPartRequest mocks base method.
func (m *MockS3) UploadPartRequest(arg0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPartRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.UploadPartOutput)
	return ret0, ret1
}

// UploadPartRequest indicates an expected call of UploadPartRequest.
func (mr *MockS3MockRecorder) UploadPartRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartRequest", reflect.TypeOf((*MockS3)(nil).UploadPartRequest), arg0)
}

// UploadPartWithContext mocks base method.
func (m *MockS3) UploadPartWithContext(arg0 context.Context, arg1 *s3.UploadPartInput, arg2 ...request.Option) (*s3.UploadPartOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadPartWithContext", varargs...)
	ret0, _ := ret[0].(*s3.UploadPartOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPartWithContext indicates an expected call of UploadPartWithContext.
func (mr *MockS3MockRecorder) UploadPartWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartWithContext", reflect.TypeOf((*MockS3)(nil).UploadPartWithContext), varargs...)
}

// WaitUntilBucketExists mocks base method.
func (m *MockS3) WaitUntilBucketExists(arg0 *s3.HeadBucketInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilBucketExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilBucketExists indicates an expected call of WaitUntilBucketExists.
func (mr *MockS3MockRecorder) WaitUntilBucketExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketExists", reflect.TypeOf((*MockS3)(nil).WaitUntilBucketExists), arg0)
}

// WaitUntilBucketExistsWithContext mocks base method.
func (m *MockS3) WaitUntilBucketExistsWithContext(arg0 context.Context, arg1 *s3.HeadBucketInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilBucketExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilBucketExistsWithContext indicates an expected call of WaitUntilBucketExistsWithContext.
func (mr *MockS3MockRecorder) WaitUntilBucketExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketExistsWithContext", reflect.TypeOf((*MockS3)(nil).WaitUntilBucketExistsWithContext), varargs...)
}

// WaitUntilBucketNotExists mocks base method.
func (m *MockS3) WaitUntilBucketNotExists(arg0 *s3.HeadBucketInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilBucketNotExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilBucketNotExists indicates an expected call of WaitUntilBucketNotExists.
func (mr *MockS3MockRecorder) WaitUntilBucketNotExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketNotExists", reflect.TypeOf((*MockS3)(nil).WaitUntilBucketNotExists), arg0)
}

// WaitUntilBucketNotExistsWithContext mocks base method.
func (m *MockS3) WaitUntilBucketNotExistsWithContext(arg0 context.Context, arg1 *s3.HeadBucketInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilBucketNotExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilBucketNotExistsWithContext indicates an expected call of WaitUntilBucketNotExistsWithContext.
func (mr *MockS3MockRecorder) WaitUntilBucketNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketNotExistsWithContext", reflect.TypeOf((*MockS3)(nil).WaitUntilBucketNotExistsWithContext), varargs...)
}

// WaitUntilObjectExists mocks base method.
func (m *MockS3) WaitUntilObjectExists(arg0 *s3.HeadObjectInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilObjectExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilObjectExists indicates an expected call of WaitUntilObjectExists.
func (mr *MockS3MockRecorder) WaitUntilObjectExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectExists", reflect.TypeOf((*MockS3)(nil).WaitUntilObjectExists), arg0)
}

// WaitUntilObjectExistsWithContext mocks base method.
func (m *MockS3) WaitUntilObjectExistsWithContext(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilObjectExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilObjectExistsWithContext indicates an expected call of WaitUntilObjectExistsWithContext.
func (mr *MockS3MockRecorder) WaitUntilObjectExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectExistsWithContext", reflect.TypeOf((*MockS3)(nil).WaitUntilObjectExistsWithContext), varargs...)
}

// WaitUntilObjectNotExists mocks base method.
func (m *MockS3) WaitUntilObjectNotExists(arg0 *s3.HeadObjectInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilObjectNotExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilObjectNotExists indicates an expected call of WaitUntilObjectNotExists.
func (mr *MockS3MockRecorder) WaitUntilObjectNotExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectNotExists", reflect.TypeOf((*MockS3)(nil).WaitUntilObjectNotExists), arg0)
}

// WaitUntilObjectNotExistsWithContext mocks base method.
func (m *MockS3) WaitUntilObjectNotExistsWithContext(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilObjectNotExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilObjectNotExistsWithContext indicates an expected call of WaitUntilObjectNotExistsWithContext.
func (mr *MockS3MockRecorder) WaitUntilObjectNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectNotExistsWithContext", reflect.TypeOf((*MockS3)(nil).WaitUntilObjectNotExistsWithContext), varargs...)
}

// WriteGetObjectResponse mocks base method.
func (m *MockS3) WriteGetObjectResponse(arg0 *s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteGetObjectResponse", arg0)
	ret0, _ := ret[0].(*s3.WriteGetObjectResponseOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteGetObjectResponse indicates an expected call of WriteGetObjectResponse.
func (mr *MockS3MockRecorder) WriteGetObjectResponse(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteGetObjectResponse", reflect.TypeOf((*MockS3)(nil).WriteGetObjectResponse), arg0)
}

// WriteGetObjectResponseRequest mocks base method.
func (m *MockS3) WriteGetObjectResponseRequest(arg0 *s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteGetObjectResponseRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*s3.WriteGetObjectResponseOutput)
	return ret0, ret1
}

// WriteGetObjectResponseRequest indicates an expected call of WriteGetObjectResponseRequest.
func (mr *MockS3MockRecorder) WriteGetObjectResponseRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteGetObjectResponseRequest", reflect.TypeOf((*MockS3)(nil).WriteGetObjectResponseRequest), arg0)
}

// WriteGetObjectResponseWithContext mocks base method.
func (m *MockS3) WriteGetObjectResponseWithContext(arg0 context.Context, arg1 *s3.WriteGetObjectResponseInput, arg2 ...request.Option) (*s3.WriteGetObjectResponseOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WriteGetObjectResponseWithContext", varargs...)
	ret0, _ := ret[0].(*s3.WriteGetObjectResponseOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteGetObjectResponseWithContext indicates an expected call of WriteGetObjectResponseWithContext.
func (mr *MockS3MockRecorder) WriteGetObjectResponseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteGetObjectResponseWithContext", reflect.TypeOf((*MockS3)(nil).WriteGetObjectResponseWithContext), varargs...)
}