query-orchestration/mocks/objectstore/mock_S3Client.go

// Code generated by mockery v2.52.3. DO NOT EDIT.

package objectstoremock

import (
	context "context"

	mock "github.com/stretchr/testify/mock"

	s3 "github.com/aws/aws-sdk-go-v2/service/s3"
)

// MockS3Client is an autogenerated mock type for the S3Client type
type MockS3Client struct {
	mock.Mock
}

type MockS3Client_Expecter struct {
	mock *mock.Mock
}

func (_m *MockS3Client) EXPECT() *MockS3Client_Expecter {
	return &MockS3Client_Expecter{mock: &_m.Mock}
}

// AbortMultipartUpload provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) AbortMultipartUpload(ctx context.Context, params *s3.AbortMultipartUploadInput, opts ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AbortMultipartUpload")
	}

	var r0 *s3.AbortMultipartUploadOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) *s3.AbortMultipartUploadOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.AbortMultipartUploadOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_AbortMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUpload'
type MockS3Client_AbortMultipartUpload_Call struct {
	*mock.Call
}

// AbortMultipartUpload is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.AbortMultipartUploadInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) AbortMultipartUpload(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_AbortMultipartUpload_Call {
	return &MockS3Client_AbortMultipartUpload_Call{Call: _e.mock.On("AbortMultipartUpload",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_AbortMultipartUpload_Call) Run(run func(ctx context.Context, params *s3.AbortMultipartUploadInput, opts ...func(*s3.Options))) *MockS3Client_AbortMultipartUpload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.AbortMultipartUploadInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_AbortMultipartUpload_Call) Return(_a0 *s3.AbortMultipartUploadOutput, _a1 error) *MockS3Client_AbortMultipartUpload_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_AbortMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)) *MockS3Client_AbortMultipartUpload_Call {
	_c.Call.Return(run)
	return _c
}

// CompleteMultipartUpload provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) CompleteMultipartUpload(ctx context.Context, params *s3.CompleteMultipartUploadInput, opts ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CompleteMultipartUpload")
	}

	var r0 *s3.CompleteMultipartUploadOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) *s3.CompleteMultipartUploadOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.CompleteMultipartUploadOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_CompleteMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUpload'
type MockS3Client_CompleteMultipartUpload_Call struct {
	*mock.Call
}

// CompleteMultipartUpload is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.CompleteMultipartUploadInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) CompleteMultipartUpload(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_CompleteMultipartUpload_Call {
	return &MockS3Client_CompleteMultipartUpload_Call{Call: _e.mock.On("CompleteMultipartUpload",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_CompleteMultipartUpload_Call) Run(run func(ctx context.Context, params *s3.CompleteMultipartUploadInput, opts ...func(*s3.Options))) *MockS3Client_CompleteMultipartUpload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.CompleteMultipartUploadInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_CompleteMultipartUpload_Call) Return(_a0 *s3.CompleteMultipartUploadOutput, _a1 error) *MockS3Client_CompleteMultipartUpload_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_CompleteMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)) *MockS3Client_CompleteMultipartUpload_Call {
	_c.Call.Return(run)
	return _c
}

// CopyObject provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) CopyObject(ctx context.Context, params *s3.CopyObjectInput, opts ...func(*s3.Options)) (*s3.CopyObjectOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CopyObject")
	}

	var r0 *s3.CopyObjectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) (*s3.CopyObjectOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) *s3.CopyObjectOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.CopyObjectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_CopyObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObject'
type MockS3Client_CopyObject_Call struct {
	*mock.Call
}

// CopyObject is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.CopyObjectInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) CopyObject(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_CopyObject_Call {
	return &MockS3Client_CopyObject_Call{Call: _e.mock.On("CopyObject",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_CopyObject_Call) Run(run func(ctx context.Context, params *s3.CopyObjectInput, opts ...func(*s3.Options))) *MockS3Client_CopyObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.CopyObjectInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_CopyObject_Call) Return(_a0 *s3.CopyObjectOutput, _a1 error) *MockS3Client_CopyObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_CopyObject_Call) RunAndReturn(run func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) (*s3.CopyObjectOutput, error)) *MockS3Client_CopyObject_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBucket provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) CreateBucket(ctx context.Context, params *s3.CreateBucketInput, opts ...func(*s3.Options)) (*s3.CreateBucketOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateBucket")
	}

	var r0 *s3.CreateBucketOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateBucketInput, ...func(*s3.Options)) (*s3.CreateBucketOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateBucketInput, ...func(*s3.Options)) *s3.CreateBucketOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.CreateBucketOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.CreateBucketInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_CreateBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucket'
type MockS3Client_CreateBucket_Call struct {
	*mock.Call
}

// CreateBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.CreateBucketInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) CreateBucket(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_CreateBucket_Call {
	return &MockS3Client_CreateBucket_Call{Call: _e.mock.On("CreateBucket",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_CreateBucket_Call) Run(run func(ctx context.Context, params *s3.CreateBucketInput, opts ...func(*s3.Options))) *MockS3Client_CreateBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.CreateBucketInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_CreateBucket_Call) Return(_a0 *s3.CreateBucketOutput, _a1 error) *MockS3Client_CreateBucket_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_CreateBucket_Call) RunAndReturn(run func(context.Context, *s3.CreateBucketInput, ...func(*s3.Options)) (*s3.CreateBucketOutput, error)) *MockS3Client_CreateBucket_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMultipartUpload provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) CreateMultipartUpload(ctx context.Context, params *s3.CreateMultipartUploadInput, opts ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateMultipartUpload")
	}

	var r0 *s3.CreateMultipartUploadOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) *s3.CreateMultipartUploadOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.CreateMultipartUploadOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_CreateMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUpload'
type MockS3Client_CreateMultipartUpload_Call struct {
	*mock.Call
}

// CreateMultipartUpload is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.CreateMultipartUploadInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) CreateMultipartUpload(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_CreateMultipartUpload_Call {
	return &MockS3Client_CreateMultipartUpload_Call{Call: _e.mock.On("CreateMultipartUpload",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_CreateMultipartUpload_Call) Run(run func(ctx context.Context, params *s3.CreateMultipartUploadInput, opts ...func(*s3.Options))) *MockS3Client_CreateMultipartUpload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.CreateMultipartUploadInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_CreateMultipartUpload_Call) Return(_a0 *s3.CreateMultipartUploadOutput, _a1 error) *MockS3Client_CreateMultipartUpload_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_CreateMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)) *MockS3Client_CreateMultipartUpload_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteBucket provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) DeleteBucket(ctx context.Context, params *s3.DeleteBucketInput, opts ...func(*s3.Options)) (*s3.DeleteBucketOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteBucket")
	}

	var r0 *s3.DeleteBucketOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketInput, ...func(*s3.Options)) (*s3.DeleteBucketOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketInput, ...func(*s3.Options)) *s3.DeleteBucketOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.DeleteBucketOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_DeleteBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucket'
type MockS3Client_DeleteBucket_Call struct {
	*mock.Call
}

// DeleteBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.DeleteBucketInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) DeleteBucket(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_DeleteBucket_Call {
	return &MockS3Client_DeleteBucket_Call{Call: _e.mock.On("DeleteBucket",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_DeleteBucket_Call) Run(run func(ctx context.Context, params *s3.DeleteBucketInput, opts ...func(*s3.Options))) *MockS3Client_DeleteBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.DeleteBucketInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_DeleteBucket_Call) Return(_a0 *s3.DeleteBucketOutput, _a1 error) *MockS3Client_DeleteBucket_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_DeleteBucket_Call) RunAndReturn(run func(context.Context, *s3.DeleteBucketInput, ...func(*s3.Options)) (*s3.DeleteBucketOutput, error)) *MockS3Client_DeleteBucket_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteBucketLifecycle provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) DeleteBucketLifecycle(ctx context.Context, params *s3.DeleteBucketLifecycleInput, opts ...func(*s3.Options)) (*s3.DeleteBucketLifecycleOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteBucketLifecycle")
	}

	var r0 *s3.DeleteBucketLifecycleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketLifecycleInput, ...func(*s3.Options)) (*s3.DeleteBucketLifecycleOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketLifecycleInput, ...func(*s3.Options)) *s3.DeleteBucketLifecycleOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.DeleteBucketLifecycleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketLifecycleInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_DeleteBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycle'
type MockS3Client_DeleteBucketLifecycle_Call struct {
	*mock.Call
}

// DeleteBucketLifecycle is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.DeleteBucketLifecycleInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) DeleteBucketLifecycle(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_DeleteBucketLifecycle_Call {
	return &MockS3Client_DeleteBucketLifecycle_Call{Call: _e.mock.On("DeleteBucketLifecycle",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_DeleteBucketLifecycle_Call) Run(run func(ctx context.Context, params *s3.DeleteBucketLifecycleInput, opts ...func(*s3.Options))) *MockS3Client_DeleteBucketLifecycle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.DeleteBucketLifecycleInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_DeleteBucketLifecycle_Call) Return(_a0 *s3.DeleteBucketLifecycleOutput, _a1 error) *MockS3Client_DeleteBucketLifecycle_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_DeleteBucketLifecycle_Call) RunAndReturn(run func(context.Context, *s3.DeleteBucketLifecycleInput, ...func(*s3.Options)) (*s3.DeleteBucketLifecycleOutput, error)) *MockS3Client_DeleteBucketLifecycle_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteObject provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) DeleteObject(ctx context.Context, params *s3.DeleteObjectInput, opts ...func(*s3.Options)) (*s3.DeleteObjectOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteObject")
	}

	var r0 *s3.DeleteObjectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) *s3.DeleteObjectOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.DeleteObjectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_DeleteObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObject'
type MockS3Client_DeleteObject_Call struct {
	*mock.Call
}

// DeleteObject is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.DeleteObjectInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) DeleteObject(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_DeleteObject_Call {
	return &MockS3Client_DeleteObject_Call{Call: _e.mock.On("DeleteObject",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_DeleteObject_Call) Run(run func(ctx context.Context, params *s3.DeleteObjectInput, opts ...func(*s3.Options))) *MockS3Client_DeleteObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.DeleteObjectInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_DeleteObject_Call) Return(_a0 *s3.DeleteObjectOutput, _a1 error) *MockS3Client_DeleteObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_DeleteObject_Call) RunAndReturn(run func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)) *MockS3Client_DeleteObject_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteObjectTagging provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) DeleteObjectTagging(ctx context.Context, params *s3.DeleteObjectTaggingInput, opts ...func(*s3.Options)) (*s3.DeleteObjectTaggingOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteObjectTagging")
	}

	var r0 *s3.DeleteObjectTaggingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectTaggingInput, ...func(*s3.Options)) (*s3.DeleteObjectTaggingOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectTaggingInput, ...func(*s3.Options)) *s3.DeleteObjectTaggingOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.DeleteObjectTaggingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectTaggingInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_DeleteObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTagging'
type MockS3Client_DeleteObjectTagging_Call struct {
	*mock.Call
}

// DeleteObjectTagging is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.DeleteObjectTaggingInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) DeleteObjectTagging(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_DeleteObjectTagging_Call {
	return &MockS3Client_DeleteObjectTagging_Call{Call: _e.mock.On("DeleteObjectTagging",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_DeleteObjectTagging_Call) Run(run func(ctx context.Context, params *s3.DeleteObjectTaggingInput, opts ...func(*s3.Options))) *MockS3Client_DeleteObjectTagging_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.DeleteObjectTaggingInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_DeleteObjectTagging_Call) Return(_a0 *s3.DeleteObjectTaggingOutput, _a1 error) *MockS3Client_DeleteObjectTagging_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_DeleteObjectTagging_Call) RunAndReturn(run func(context.Context, *s3.DeleteObjectTaggingInput, ...func(*s3.Options)) (*s3.DeleteObjectTaggingOutput, error)) *MockS3Client_DeleteObjectTagging_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteObjects provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) DeleteObjects(ctx context.Context, params *s3.DeleteObjectsInput, opts ...func(*s3.Options)) (*s3.DeleteObjectsOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteObjects")
	}

	var r0 *s3.DeleteObjectsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectsInput, ...func(*s3.Options)) (*s3.DeleteObjectsOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectsInput, ...func(*s3.Options)) *s3.DeleteObjectsOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.DeleteObjectsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectsInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_DeleteObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjects'
type MockS3Client_DeleteObjects_Call struct {
	*mock.Call
}

// DeleteObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.DeleteObjectsInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) DeleteObjects(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_DeleteObjects_Call {
	return &MockS3Client_DeleteObjects_Call{Call: _e.mock.On("DeleteObjects",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_DeleteObjects_Call) Run(run func(ctx context.Context, params *s3.DeleteObjectsInput, opts ...func(*s3.Options))) *MockS3Client_DeleteObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.DeleteObjectsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_DeleteObjects_Call) Return(_a0 *s3.DeleteObjectsOutput, _a1 error) *MockS3Client_DeleteObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_DeleteObjects_Call) RunAndReturn(run func(context.Context, *s3.DeleteObjectsInput, ...func(*s3.Options)) (*s3.DeleteObjectsOutput, error)) *MockS3Client_DeleteObjects_Call {
	_c.Call.Return(run)
	return _c
}

// GetBucketAcl provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) GetBucketAcl(ctx context.Context, params *s3.GetBucketAclInput, opts ...func(*s3.Options)) (*s3.GetBucketAclOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetBucketAcl")
	}

	var r0 *s3.GetBucketAclOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAclInput, ...func(*s3.Options)) (*s3.GetBucketAclOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAclInput, ...func(*s3.Options)) *s3.GetBucketAclOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.GetBucketAclOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketAclInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_GetBucketAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAcl'
type MockS3Client_GetBucketAcl_Call struct {
	*mock.Call
}

// GetBucketAcl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.GetBucketAclInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) GetBucketAcl(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_GetBucketAcl_Call {
	return &MockS3Client_GetBucketAcl_Call{Call: _e.mock.On("GetBucketAcl",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_GetBucketAcl_Call) Run(run func(ctx context.Context, params *s3.GetBucketAclInput, opts ...func(*s3.Options))) *MockS3Client_GetBucketAcl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.GetBucketAclInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_GetBucketAcl_Call) Return(_a0 *s3.GetBucketAclOutput, _a1 error) *MockS3Client_GetBucketAcl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_GetBucketAcl_Call) RunAndReturn(run func(context.Context, *s3.GetBucketAclInput, ...func(*s3.Options)) (*s3.GetBucketAclOutput, error)) *MockS3Client_GetBucketAcl_Call {
	_c.Call.Return(run)
	return _c
}

// GetBucketLifecycleConfiguration provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) GetBucketLifecycleConfiguration(ctx context.Context, params *s3.GetBucketLifecycleConfigurationInput, opts ...func(*s3.Options)) (*s3.GetBucketLifecycleConfigurationOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetBucketLifecycleConfiguration")
	}

	var r0 *s3.GetBucketLifecycleConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...func(*s3.Options)) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...func(*s3.Options)) *s3.GetBucketLifecycleConfigurationOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.GetBucketLifecycleConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_GetBucketLifecycleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfiguration'
type MockS3Client_GetBucketLifecycleConfiguration_Call struct {
	*mock.Call
}

// GetBucketLifecycleConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.GetBucketLifecycleConfigurationInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) GetBucketLifecycleConfiguration(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_GetBucketLifecycleConfiguration_Call {
	return &MockS3Client_GetBucketLifecycleConfiguration_Call{Call: _e.mock.On("GetBucketLifecycleConfiguration",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_GetBucketLifecycleConfiguration_Call) Run(run func(ctx context.Context, params *s3.GetBucketLifecycleConfigurationInput, opts ...func(*s3.Options))) *MockS3Client_GetBucketLifecycleConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.GetBucketLifecycleConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_GetBucketLifecycleConfiguration_Call) Return(_a0 *s3.GetBucketLifecycleConfigurationOutput, _a1 error) *MockS3Client_GetBucketLifecycleConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_GetBucketLifecycleConfiguration_Call) RunAndReturn(run func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...func(*s3.Options)) (*s3.GetBucketLifecycleConfigurationOutput, error)) *MockS3Client_GetBucketLifecycleConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetBucketNotificationConfiguration provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) GetBucketNotificationConfiguration(ctx context.Context, params *s3.GetBucketNotificationConfigurationInput, opts ...func(*s3.Options)) (*s3.GetBucketNotificationConfigurationOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetBucketNotificationConfiguration")
	}

	var r0 *s3.GetBucketNotificationConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketNotificationConfigurationInput, ...func(*s3.Options)) (*s3.GetBucketNotificationConfigurationOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketNotificationConfigurationInput, ...func(*s3.Options)) *s3.GetBucketNotificationConfigurationOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.GetBucketNotificationConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketNotificationConfigurationInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_GetBucketNotificationConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfiguration'
type MockS3Client_GetBucketNotificationConfiguration_Call struct {
	*mock.Call
}

// GetBucketNotificationConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.GetBucketNotificationConfigurationInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) GetBucketNotificationConfiguration(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_GetBucketNotificationConfiguration_Call {
	return &MockS3Client_GetBucketNotificationConfiguration_Call{Call: _e.mock.On("GetBucketNotificationConfiguration",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_GetBucketNotificationConfiguration_Call) Run(run func(ctx context.Context, params *s3.GetBucketNotificationConfigurationInput, opts ...func(*s3.Options))) *MockS3Client_GetBucketNotificationConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.GetBucketNotificationConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_GetBucketNotificationConfiguration_Call) Return(_a0 *s3.GetBucketNotificationConfigurationOutput, _a1 error) *MockS3Client_GetBucketNotificationConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_GetBucketNotificationConfiguration_Call) RunAndReturn(run func(context.Context, *s3.GetBucketNotificationConfigurationInput, ...func(*s3.Options)) (*s3.GetBucketNotificationConfigurationOutput, error)) *MockS3Client_GetBucketNotificationConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetObject provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) GetObject(ctx context.Context, params *s3.GetObjectInput, opts ...func(*s3.Options)) (*s3.GetObjectOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetObject")
	}

	var r0 *s3.GetObjectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) *s3.GetObjectOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.GetObjectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_GetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObject'
type MockS3Client_GetObject_Call struct {
	*mock.Call
}

// GetObject is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.GetObjectInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) GetObject(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_GetObject_Call {
	return &MockS3Client_GetObject_Call{Call: _e.mock.On("GetObject",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_GetObject_Call) Run(run func(ctx context.Context, params *s3.GetObjectInput, opts ...func(*s3.Options))) *MockS3Client_GetObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.GetObjectInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_GetObject_Call) Return(_a0 *s3.GetObjectOutput, _a1 error) *MockS3Client_GetObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_GetObject_Call) RunAndReturn(run func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)) *MockS3Client_GetObject_Call {
	_c.Call.Return(run)
	return _c
}

// GetObjectAcl provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) GetObjectAcl(ctx context.Context, params *s3.GetObjectAclInput, opts ...func(*s3.Options)) (*s3.GetObjectAclOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetObjectAcl")
	}

	var r0 *s3.GetObjectAclOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectAclInput, ...func(*s3.Options)) (*s3.GetObjectAclOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectAclInput, ...func(*s3.Options)) *s3.GetObjectAclOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.GetObjectAclOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectAclInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_GetObjectAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAcl'
type MockS3Client_GetObjectAcl_Call struct {
	*mock.Call
}

// GetObjectAcl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.GetObjectAclInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) GetObjectAcl(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_GetObjectAcl_Call {
	return &MockS3Client_GetObjectAcl_Call{Call: _e.mock.On("GetObjectAcl",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_GetObjectAcl_Call) Run(run func(ctx context.Context, params *s3.GetObjectAclInput, opts ...func(*s3.Options))) *MockS3Client_GetObjectAcl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.GetObjectAclInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_GetObjectAcl_Call) Return(_a0 *s3.GetObjectAclOutput, _a1 error) *MockS3Client_GetObjectAcl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_GetObjectAcl_Call) RunAndReturn(run func(context.Context, *s3.GetObjectAclInput, ...func(*s3.Options)) (*s3.GetObjectAclOutput, error)) *MockS3Client_GetObjectAcl_Call {
	_c.Call.Return(run)
	return _c
}

// GetObjectTagging provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) GetObjectTagging(ctx context.Context, params *s3.GetObjectTaggingInput, opts ...func(*s3.Options)) (*s3.GetObjectTaggingOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetObjectTagging")
	}

	var r0 *s3.GetObjectTaggingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectTaggingInput, ...func(*s3.Options)) (*s3.GetObjectTaggingOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectTaggingInput, ...func(*s3.Options)) *s3.GetObjectTaggingOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.GetObjectTaggingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectTaggingInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_GetObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTagging'
type MockS3Client_GetObjectTagging_Call struct {
	*mock.Call
}

// GetObjectTagging is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.GetObjectTaggingInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) GetObjectTagging(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_GetObjectTagging_Call {
	return &MockS3Client_GetObjectTagging_Call{Call: _e.mock.On("GetObjectTagging",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_GetObjectTagging_Call) Run(run func(ctx context.Context, params *s3.GetObjectTaggingInput, opts ...func(*s3.Options))) *MockS3Client_GetObjectTagging_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.GetObjectTaggingInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_GetObjectTagging_Call) Return(_a0 *s3.GetObjectTaggingOutput, _a1 error) *MockS3Client_GetObjectTagging_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_GetObjectTagging_Call) RunAndReturn(run func(context.Context, *s3.GetObjectTaggingInput, ...func(*s3.Options)) (*s3.GetObjectTaggingOutput, error)) *MockS3Client_GetObjectTagging_Call {
	_c.Call.Return(run)
	return _c
}

// HeadBucket provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) HeadBucket(ctx context.Context, params *s3.HeadBucketInput, opts ...func(*s3.Options)) (*s3.HeadBucketOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for HeadBucket")
	}

	var r0 *s3.HeadBucketOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) (*s3.HeadBucketOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) *s3.HeadBucketOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.HeadBucketOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_HeadBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucket'
type MockS3Client_HeadBucket_Call struct {
	*mock.Call
}

// HeadBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.HeadBucketInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) HeadBucket(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_HeadBucket_Call {
	return &MockS3Client_HeadBucket_Call{Call: _e.mock.On("HeadBucket",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_HeadBucket_Call) Run(run func(ctx context.Context, params *s3.HeadBucketInput, opts ...func(*s3.Options))) *MockS3Client_HeadBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.HeadBucketInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_HeadBucket_Call) Return(_a0 *s3.HeadBucketOutput, _a1 error) *MockS3Client_HeadBucket_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_HeadBucket_Call) RunAndReturn(run func(context.Context, *s3.HeadBucketInput, ...func(*s3.Options)) (*s3.HeadBucketOutput, error)) *MockS3Client_HeadBucket_Call {
	_c.Call.Return(run)
	return _c
}

// HeadObject provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) HeadObject(ctx context.Context, params *s3.HeadObjectInput, opts ...func(*s3.Options)) (*s3.HeadObjectOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for HeadObject")
	}

	var r0 *s3.HeadObjectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) (*s3.HeadObjectOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) *s3.HeadObjectOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.HeadObjectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_HeadObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObject'
type MockS3Client_HeadObject_Call struct {
	*mock.Call
}

// HeadObject is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.HeadObjectInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) HeadObject(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_HeadObject_Call {
	return &MockS3Client_HeadObject_Call{Call: _e.mock.On("HeadObject",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_HeadObject_Call) Run(run func(ctx context.Context, params *s3.HeadObjectInput, opts ...func(*s3.Options))) *MockS3Client_HeadObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.HeadObjectInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_HeadObject_Call) Return(_a0 *s3.HeadObjectOutput, _a1 error) *MockS3Client_HeadObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_HeadObject_Call) RunAndReturn(run func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) (*s3.HeadObjectOutput, error)) *MockS3Client_HeadObject_Call {
	_c.Call.Return(run)
	return _c
}

// ListBuckets provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) ListBuckets(ctx context.Context, params *s3.ListBucketsInput, opts ...func(*s3.Options)) (*s3.ListBucketsOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListBuckets")
	}

	var r0 *s3.ListBucketsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketsInput, ...func(*s3.Options)) (*s3.ListBucketsOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketsInput, ...func(*s3.Options)) *s3.ListBucketsOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.ListBucketsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListBucketsInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_ListBuckets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBuckets'
type MockS3Client_ListBuckets_Call struct {
	*mock.Call
}

// ListBuckets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.ListBucketsInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) ListBuckets(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_ListBuckets_Call {
	return &MockS3Client_ListBuckets_Call{Call: _e.mock.On("ListBuckets",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_ListBuckets_Call) Run(run func(ctx context.Context, params *s3.ListBucketsInput, opts ...func(*s3.Options))) *MockS3Client_ListBuckets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.ListBucketsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_ListBuckets_Call) Return(_a0 *s3.ListBucketsOutput, _a1 error) *MockS3Client_ListBuckets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_ListBuckets_Call) RunAndReturn(run func(context.Context, *s3.ListBucketsInput, ...func(*s3.Options)) (*s3.ListBucketsOutput, error)) *MockS3Client_ListBuckets_Call {
	_c.Call.Return(run)
	return _c
}

// ListMultipartUploads provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) ListMultipartUploads(ctx context.Context, params *s3.ListMultipartUploadsInput, opts ...func(*s3.Options)) (*s3.ListMultipartUploadsOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListMultipartUploads")
	}

	var r0 *s3.ListMultipartUploadsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListMultipartUploadsInput, ...func(*s3.Options)) (*s3.ListMultipartUploadsOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListMultipartUploadsInput, ...func(*s3.Options)) *s3.ListMultipartUploadsOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.ListMultipartUploadsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListMultipartUploadsInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_ListMultipartUploads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploads'
type MockS3Client_ListMultipartUploads_Call struct {
	*mock.Call
}

// ListMultipartUploads is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.ListMultipartUploadsInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) ListMultipartUploads(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_ListMultipartUploads_Call {
	return &MockS3Client_ListMultipartUploads_Call{Call: _e.mock.On("ListMultipartUploads",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_ListMultipartUploads_Call) Run(run func(ctx context.Context, params *s3.ListMultipartUploadsInput, opts ...func(*s3.Options))) *MockS3Client_ListMultipartUploads_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.ListMultipartUploadsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_ListMultipartUploads_Call) Return(_a0 *s3.ListMultipartUploadsOutput, _a1 error) *MockS3Client_ListMultipartUploads_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_ListMultipartUploads_Call) RunAndReturn(run func(context.Context, *s3.ListMultipartUploadsInput, ...func(*s3.Options)) (*s3.ListMultipartUploadsOutput, error)) *MockS3Client_ListMultipartUploads_Call {
	_c.Call.Return(run)
	return _c
}

// ListObjects provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) ListObjects(ctx context.Context, params *s3.ListObjectsInput, opts ...func(*s3.Options)) (*s3.ListObjectsOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListObjects")
	}

	var r0 *s3.ListObjectsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) (*s3.ListObjectsOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) *s3.ListObjectsOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.ListObjectsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_ListObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjects'
type MockS3Client_ListObjects_Call struct {
	*mock.Call
}

// ListObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.ListObjectsInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) ListObjects(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_ListObjects_Call {
	return &MockS3Client_ListObjects_Call{Call: _e.mock.On("ListObjects",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_ListObjects_Call) Run(run func(ctx context.Context, params *s3.ListObjectsInput, opts ...func(*s3.Options))) *MockS3Client_ListObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.ListObjectsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_ListObjects_Call) Return(_a0 *s3.ListObjectsOutput, _a1 error) *MockS3Client_ListObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_ListObjects_Call) RunAndReturn(run func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) (*s3.ListObjectsOutput, error)) *MockS3Client_ListObjects_Call {
	_c.Call.Return(run)
	return _c
}

// ListObjectsV2 provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) ListObjectsV2(ctx context.Context, params *s3.ListObjectsV2Input, opts ...func(*s3.Options)) (*s3.ListObjectsV2Output, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListObjectsV2")
	}

	var r0 *s3.ListObjectsV2Output
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsV2Input, ...func(*s3.Options)) (*s3.ListObjectsV2Output, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsV2Input, ...func(*s3.Options)) *s3.ListObjectsV2Output); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.ListObjectsV2Output)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectsV2Input, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_ListObjectsV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2'
type MockS3Client_ListObjectsV2_Call struct {
	*mock.Call
}

// ListObjectsV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.ListObjectsV2Input
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) ListObjectsV2(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_ListObjectsV2_Call {
	return &MockS3Client_ListObjectsV2_Call{Call: _e.mock.On("ListObjectsV2",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_ListObjectsV2_Call) Run(run func(ctx context.Context, params *s3.ListObjectsV2Input, opts ...func(*s3.Options))) *MockS3Client_ListObjectsV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.ListObjectsV2Input), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_ListObjectsV2_Call) Return(_a0 *s3.ListObjectsV2Output, _a1 error) *MockS3Client_ListObjectsV2_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_ListObjectsV2_Call) RunAndReturn(run func(context.Context, *s3.ListObjectsV2Input, ...func(*s3.Options)) (*s3.ListObjectsV2Output, error)) *MockS3Client_ListObjectsV2_Call {
	_c.Call.Return(run)
	return _c
}

// ListParts provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) ListParts(ctx context.Context, params *s3.ListPartsInput, opts ...func(*s3.Options)) (*s3.ListPartsOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListParts")
	}

	var r0 *s3.ListPartsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListPartsInput, ...func(*s3.Options)) (*s3.ListPartsOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.ListPartsInput, ...func(*s3.Options)) *s3.ListPartsOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.ListPartsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.ListPartsInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_ListParts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListParts'
type MockS3Client_ListParts_Call struct {
	*mock.Call
}

// ListParts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.ListPartsInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) ListParts(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_ListParts_Call {
	return &MockS3Client_ListParts_Call{Call: _e.mock.On("ListParts",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_ListParts_Call) Run(run func(ctx context.Context, params *s3.ListPartsInput, opts ...func(*s3.Options))) *MockS3Client_ListParts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.ListPartsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_ListParts_Call) Return(_a0 *s3.ListPartsOutput, _a1 error) *MockS3Client_ListParts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_ListParts_Call) RunAndReturn(run func(context.Context, *s3.ListPartsInput, ...func(*s3.Options)) (*s3.ListPartsOutput, error)) *MockS3Client_ListParts_Call {
	_c.Call.Return(run)
	return _c
}

// PutBucketAcl provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) PutBucketAcl(ctx context.Context, params *s3.PutBucketAclInput, opts ...func(*s3.Options)) (*s3.PutBucketAclOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PutBucketAcl")
	}

	var r0 *s3.PutBucketAclOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAclInput, ...func(*s3.Options)) (*s3.PutBucketAclOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAclInput, ...func(*s3.Options)) *s3.PutBucketAclOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.PutBucketAclOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketAclInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_PutBucketAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAcl'
type MockS3Client_PutBucketAcl_Call struct {
	*mock.Call
}

// PutBucketAcl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.PutBucketAclInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) PutBucketAcl(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_PutBucketAcl_Call {
	return &MockS3Client_PutBucketAcl_Call{Call: _e.mock.On("PutBucketAcl",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_PutBucketAcl_Call) Run(run func(ctx context.Context, params *s3.PutBucketAclInput, opts ...func(*s3.Options))) *MockS3Client_PutBucketAcl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.PutBucketAclInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_PutBucketAcl_Call) Return(_a0 *s3.PutBucketAclOutput, _a1 error) *MockS3Client_PutBucketAcl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_PutBucketAcl_Call) RunAndReturn(run func(context.Context, *s3.PutBucketAclInput, ...func(*s3.Options)) (*s3.PutBucketAclOutput, error)) *MockS3Client_PutBucketAcl_Call {
	_c.Call.Return(run)
	return _c
}

// PutBucketLifecycleConfiguration provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) PutBucketLifecycleConfiguration(ctx context.Context, params *s3.PutBucketLifecycleConfigurationInput, opts ...func(*s3.Options)) (*s3.PutBucketLifecycleConfigurationOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PutBucketLifecycleConfiguration")
	}

	var r0 *s3.PutBucketLifecycleConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...func(*s3.Options)) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...func(*s3.Options)) *s3.PutBucketLifecycleConfigurationOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.PutBucketLifecycleConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_PutBucketLifecycleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfiguration'
type MockS3Client_PutBucketLifecycleConfiguration_Call struct {
	*mock.Call
}

// PutBucketLifecycleConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.PutBucketLifecycleConfigurationInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) PutBucketLifecycleConfiguration(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_PutBucketLifecycleConfiguration_Call {
	return &MockS3Client_PutBucketLifecycleConfiguration_Call{Call: _e.mock.On("PutBucketLifecycleConfiguration",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_PutBucketLifecycleConfiguration_Call) Run(run func(ctx context.Context, params *s3.PutBucketLifecycleConfigurationInput, opts ...func(*s3.Options))) *MockS3Client_PutBucketLifecycleConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.PutBucketLifecycleConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_PutBucketLifecycleConfiguration_Call) Return(_a0 *s3.PutBucketLifecycleConfigurationOutput, _a1 error) *MockS3Client_PutBucketLifecycleConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_PutBucketLifecycleConfiguration_Call) RunAndReturn(run func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...func(*s3.Options)) (*s3.PutBucketLifecycleConfigurationOutput, error)) *MockS3Client_PutBucketLifecycleConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// PutBucketNotificationConfiguration provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) PutBucketNotificationConfiguration(ctx context.Context, params *s3.PutBucketNotificationConfigurationInput, opts ...func(*s3.Options)) (*s3.PutBucketNotificationConfigurationOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PutBucketNotificationConfiguration")
	}

	var r0 *s3.PutBucketNotificationConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...func(*s3.Options)) (*s3.PutBucketNotificationConfigurationOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...func(*s3.Options)) *s3.PutBucketNotificationConfigurationOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.PutBucketNotificationConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_PutBucketNotificationConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfiguration'
type MockS3Client_PutBucketNotificationConfiguration_Call struct {
	*mock.Call
}

// PutBucketNotificationConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.PutBucketNotificationConfigurationInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) PutBucketNotificationConfiguration(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_PutBucketNotificationConfiguration_Call {
	return &MockS3Client_PutBucketNotificationConfiguration_Call{Call: _e.mock.On("PutBucketNotificationConfiguration",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_PutBucketNotificationConfiguration_Call) Run(run func(ctx context.Context, params *s3.PutBucketNotificationConfigurationInput, opts ...func(*s3.Options))) *MockS3Client_PutBucketNotificationConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.PutBucketNotificationConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_PutBucketNotificationConfiguration_Call) Return(_a0 *s3.PutBucketNotificationConfigurationOutput, _a1 error) *MockS3Client_PutBucketNotificationConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_PutBucketNotificationConfiguration_Call) RunAndReturn(run func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...func(*s3.Options)) (*s3.PutBucketNotificationConfigurationOutput, error)) *MockS3Client_PutBucketNotificationConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// PutObject provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) PutObject(ctx context.Context, params *s3.PutObjectInput, opts ...func(*s3.Options)) (*s3.PutObjectOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PutObject")
	}

	var r0 *s3.PutObjectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) *s3.PutObjectOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.PutObjectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_PutObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObject'
type MockS3Client_PutObject_Call struct {
	*mock.Call
}

// PutObject is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.PutObjectInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) PutObject(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_PutObject_Call {
	return &MockS3Client_PutObject_Call{Call: _e.mock.On("PutObject",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_PutObject_Call) Run(run func(ctx context.Context, params *s3.PutObjectInput, opts ...func(*s3.Options))) *MockS3Client_PutObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.PutObjectInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_PutObject_Call) Return(_a0 *s3.PutObjectOutput, _a1 error) *MockS3Client_PutObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_PutObject_Call) RunAndReturn(run func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)) *MockS3Client_PutObject_Call {
	_c.Call.Return(run)
	return _c
}

// PutObjectAcl provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) PutObjectAcl(ctx context.Context, params *s3.PutObjectAclInput, opts ...func(*s3.Options)) (*s3.PutObjectAclOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PutObjectAcl")
	}

	var r0 *s3.PutObjectAclOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectAclInput, ...func(*s3.Options)) (*s3.PutObjectAclOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectAclInput, ...func(*s3.Options)) *s3.PutObjectAclOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.PutObjectAclOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectAclInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_PutObjectAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAcl'
type MockS3Client_PutObjectAcl_Call struct {
	*mock.Call
}

// PutObjectAcl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.PutObjectAclInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) PutObjectAcl(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_PutObjectAcl_Call {
	return &MockS3Client_PutObjectAcl_Call{Call: _e.mock.On("PutObjectAcl",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_PutObjectAcl_Call) Run(run func(ctx context.Context, params *s3.PutObjectAclInput, opts ...func(*s3.Options))) *MockS3Client_PutObjectAcl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.PutObjectAclInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_PutObjectAcl_Call) Return(_a0 *s3.PutObjectAclOutput, _a1 error) *MockS3Client_PutObjectAcl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_PutObjectAcl_Call) RunAndReturn(run func(context.Context, *s3.PutObjectAclInput, ...func(*s3.Options)) (*s3.PutObjectAclOutput, error)) *MockS3Client_PutObjectAcl_Call {
	_c.Call.Return(run)
	return _c
}

// PutObjectTagging provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) PutObjectTagging(ctx context.Context, params *s3.PutObjectTaggingInput, opts ...func(*s3.Options)) (*s3.PutObjectTaggingOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PutObjectTagging")
	}

	var r0 *s3.PutObjectTaggingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectTaggingInput, ...func(*s3.Options)) (*s3.PutObjectTaggingOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectTaggingInput, ...func(*s3.Options)) *s3.PutObjectTaggingOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.PutObjectTaggingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectTaggingInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_PutObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTagging'
type MockS3Client_PutObjectTagging_Call struct {
	*mock.Call
}

// PutObjectTagging is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.PutObjectTaggingInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) PutObjectTagging(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_PutObjectTagging_Call {
	return &MockS3Client_PutObjectTagging_Call{Call: _e.mock.On("PutObjectTagging",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_PutObjectTagging_Call) Run(run func(ctx context.Context, params *s3.PutObjectTaggingInput, opts ...func(*s3.Options))) *MockS3Client_PutObjectTagging_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.PutObjectTaggingInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_PutObjectTagging_Call) Return(_a0 *s3.PutObjectTaggingOutput, _a1 error) *MockS3Client_PutObjectTagging_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_PutObjectTagging_Call) RunAndReturn(run func(context.Context, *s3.PutObjectTaggingInput, ...func(*s3.Options)) (*s3.PutObjectTaggingOutput, error)) *MockS3Client_PutObjectTagging_Call {
	_c.Call.Return(run)
	return _c
}

// UploadPart provides a mock function with given fields: ctx, params, opts
func (_m *MockS3Client) UploadPart(ctx context.Context, params *s3.UploadPartInput, opts ...func(*s3.Options)) (*s3.UploadPartOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UploadPart")
	}

	var r0 *s3.UploadPartOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) *s3.UploadPartOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*s3.UploadPartOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockS3Client_UploadPart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPart'
type MockS3Client_UploadPart_Call struct {
	*mock.Call
}

// UploadPart is a helper method to define mock.On call
//   - ctx context.Context
//   - params *s3.UploadPartInput
//   - opts ...func(*s3.Options)
func (_e *MockS3Client_Expecter) UploadPart(ctx interface{}, params interface{}, opts ...interface{}) *MockS3Client_UploadPart_Call {
	return &MockS3Client_UploadPart_Call{Call: _e.mock.On("UploadPart",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockS3Client_UploadPart_Call) Run(run func(ctx context.Context, params *s3.UploadPartInput, opts ...func(*s3.Options))) *MockS3Client_UploadPart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*s3.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*s3.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*s3.UploadPartInput), variadicArgs...)
	})
	return _c
}

func (_c *MockS3Client_UploadPart_Call) Return(_a0 *s3.UploadPartOutput, _a1 error) *MockS3Client_UploadPart_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockS3Client_UploadPart_Call) RunAndReturn(run func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)) *MockS3Client_UploadPart_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockS3Client creates a new instance of MockS3Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockS3Client(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockS3Client {
	mock := &MockS3Client{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}