// Code generated by mockery v1.0.0. DO NOT EDIT.

package aws

import (
	"context"

	"github.com/aws/aws-sdk-go/service/lambda"
	"github.com/stretchr/testify/mock"

	"github.com/aws/aws-sdk-go/aws/request"
)

// MockFakeLambda is an autogenerated mock type for the FakeLambda type
type MockFakeLambda struct {
	mock.Mock
}

// AddLayerVersionPermission provides a mock function with given fields: _a0
func (_m *MockFakeLambda) AddLayerVersionPermission(_a0 *lambda.AddLayerVersionPermissionInput) (*lambda.AddLayerVersionPermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.AddLayerVersionPermissionOutput
	if rf, ok := ret.Get(0).(func(*lambda.AddLayerVersionPermissionInput) *lambda.AddLayerVersionPermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AddLayerVersionPermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.AddLayerVersionPermissionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddLayerVersionPermissionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) AddLayerVersionPermissionRequest(_a0 *lambda.AddLayerVersionPermissionInput) (*request.Request, *lambda.AddLayerVersionPermissionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.AddLayerVersionPermissionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.AddLayerVersionPermissionOutput
	if rf, ok := ret.Get(1).(func(*lambda.AddLayerVersionPermissionInput) *lambda.AddLayerVersionPermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.AddLayerVersionPermissionOutput)
		}
	}

	return r0, r1
}

// AddLayerVersionPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) AddLayerVersionPermissionWithContext(_a0 context.Context, _a1 *lambda.AddLayerVersionPermissionInput, _a2 ...request.Option) (*lambda.AddLayerVersionPermissionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.AddLayerVersionPermissionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.AddLayerVersionPermissionInput, ...request.Option) *lambda.AddLayerVersionPermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AddLayerVersionPermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.AddLayerVersionPermissionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddPermission provides a mock function with given fields: _a0
func (_m *MockFakeLambda) AddPermission(_a0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.AddPermissionOutput
	if rf, ok := ret.Get(0).(func(*lambda.AddPermissionInput) *lambda.AddPermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AddPermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.AddPermissionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddPermissionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) AddPermissionRequest(_a0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.AddPermissionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.AddPermissionOutput
	if rf, ok := ret.Get(1).(func(*lambda.AddPermissionInput) *lambda.AddPermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.AddPermissionOutput)
		}
	}

	return r0, r1
}

// AddPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) AddPermissionWithContext(_a0 context.Context, _a1 *lambda.AddPermissionInput, _a2 ...request.Option) (*lambda.AddPermissionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.AddPermissionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.AddPermissionInput, ...request.Option) *lambda.AddPermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AddPermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.AddPermissionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAlias provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateAlias(_a0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.AliasConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.CreateAliasInput) *lambda.AliasConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AliasConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.CreateAliasInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAliasRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateAliasRequest(_a0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.CreateAliasInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.AliasConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.CreateAliasInput) *lambda.AliasConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.AliasConfiguration)
		}
	}

	return r0, r1
}

// CreateAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) CreateAliasWithContext(_a0 context.Context, _a1 *lambda.CreateAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.AliasConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateAliasInput, ...request.Option) *lambda.AliasConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AliasConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateAliasInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateCodeSigningConfig(_a0 *lambda.CreateCodeSigningConfigInput) (*lambda.CreateCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.CreateCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.CreateCodeSigningConfigInput) *lambda.CreateCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.CreateCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.CreateCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateCodeSigningConfigRequest(_a0 *lambda.CreateCodeSigningConfigInput) (*request.Request, *lambda.CreateCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.CreateCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.CreateCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.CreateCodeSigningConfigInput) *lambda.CreateCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.CreateCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// CreateCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) CreateCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.CreateCodeSigningConfigInput, _a2 ...request.Option) (*lambda.CreateCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.CreateCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateCodeSigningConfigInput, ...request.Option) *lambda.CreateCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.CreateCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEventSourceMapping provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateEventSourceMapping(_a0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.CreateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.CreateEventSourceMappingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEventSourceMappingRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateEventSourceMappingRequest(_a0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.CreateEventSourceMappingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.CreateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
		}
	}

	return r0, r1
}

// CreateEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) CreateEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.CreateEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateEventSourceMappingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFunction provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateFunction(_a0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.CreateFunctionInput) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.CreateFunctionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFunctionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) CreateFunctionRequest(_a0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.CreateFunctionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.CreateFunctionInput) *lambda.FunctionConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.FunctionConfiguration)
		}
	}

	return r0, r1
}

// CreateFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) CreateFunctionWithContext(_a0 context.Context, _a1 *lambda.CreateFunctionInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateFunctionInput, ...request.Option) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateFunctionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAlias provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteAlias(_a0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteAliasOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteAliasInput) *lambda.DeleteAliasOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteAliasOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteAliasInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAliasRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteAliasRequest(_a0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteAliasInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteAliasOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteAliasInput) *lambda.DeleteAliasOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteAliasOutput)
		}
	}

	return r0, r1
}

// DeleteAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteAliasWithContext(_a0 context.Context, _a1 *lambda.DeleteAliasInput, _a2 ...request.Option) (*lambda.DeleteAliasOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteAliasOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteAliasInput, ...request.Option) *lambda.DeleteAliasOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteAliasOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteAliasInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteCodeSigningConfig(_a0 *lambda.DeleteCodeSigningConfigInput) (*lambda.DeleteCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteCodeSigningConfigInput) *lambda.DeleteCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteCodeSigningConfigRequest(_a0 *lambda.DeleteCodeSigningConfigInput) (*request.Request, *lambda.DeleteCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteCodeSigningConfigInput) *lambda.DeleteCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// DeleteCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteCodeSigningConfigInput, _a2 ...request.Option) (*lambda.DeleteCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteCodeSigningConfigInput, ...request.Option) *lambda.DeleteCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEventSourceMapping provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteEventSourceMapping(_a0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.DeleteEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteEventSourceMappingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEventSourceMappingRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteEventSourceMappingRequest(_a0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteEventSourceMappingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.DeleteEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
		}
	}

	return r0, r1
}

// DeleteEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.DeleteEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteEventSourceMappingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunction provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunction(_a0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteFunctionOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionInput) *lambda.DeleteFunctionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionCodeSigningConfig(_a0 *lambda.DeleteFunctionCodeSigningConfigInput) (*lambda.DeleteFunctionCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionCodeSigningConfigInput) *lambda.DeleteFunctionCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionCodeSigningConfigRequest(_a0 *lambda.DeleteFunctionCodeSigningConfigInput) (*request.Request, *lambda.DeleteFunctionCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionCodeSigningConfigInput) *lambda.DeleteFunctionCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteFunctionCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// DeleteFunctionCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteFunctionCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionCodeSigningConfigInput, _a2 ...request.Option) (*lambda.DeleteFunctionCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionCodeSigningConfigInput, ...request.Option) *lambda.DeleteFunctionCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionConcurrency provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionConcurrency(_a0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteFunctionConcurrencyOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionConcurrencyInput) *lambda.DeleteFunctionConcurrencyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionConcurrencyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionConcurrencyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionConcurrencyRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionConcurrencyRequest(_a0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionConcurrencyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteFunctionConcurrencyOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionConcurrencyInput) *lambda.DeleteFunctionConcurrencyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteFunctionConcurrencyOutput)
		}
	}

	return r0, r1
}

// DeleteFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteFunctionConcurrencyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionConcurrencyInput, ...request.Option) *lambda.DeleteFunctionConcurrencyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionConcurrencyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionConcurrencyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionEventInvokeConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionEventInvokeConfig(_a0 *lambda.DeleteFunctionEventInvokeConfigInput) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionEventInvokeConfigInput) *lambda.DeleteFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionEventInvokeConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionEventInvokeConfigRequest(_a0 *lambda.DeleteFunctionEventInvokeConfigInput) (*request.Request, *lambda.DeleteFunctionEventInvokeConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionEventInvokeConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionEventInvokeConfigInput) *lambda.DeleteFunctionEventInvokeConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteFunctionEventInvokeConfigOutput)
		}
	}

	return r0, r1
}

// DeleteFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionEventInvokeConfigInput, ...request.Option) *lambda.DeleteFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionEventInvokeConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFunctionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteFunctionRequest(_a0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteFunctionOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionInput) *lambda.DeleteFunctionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteFunctionOutput)
		}
	}

	return r0, r1
}

// DeleteFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteFunctionWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionInput, _a2 ...request.Option) (*lambda.DeleteFunctionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteFunctionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionInput, ...request.Option) *lambda.DeleteFunctionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteFunctionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteLayerVersion provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteLayerVersion(_a0 *lambda.DeleteLayerVersionInput) (*lambda.DeleteLayerVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteLayerVersionOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteLayerVersionInput) *lambda.DeleteLayerVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteLayerVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteLayerVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteLayerVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteLayerVersionRequest(_a0 *lambda.DeleteLayerVersionInput) (*request.Request, *lambda.DeleteLayerVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteLayerVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteLayerVersionOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteLayerVersionInput) *lambda.DeleteLayerVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteLayerVersionOutput)
		}
	}

	return r0, r1
}

// DeleteLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteLayerVersionWithContext(_a0 context.Context, _a1 *lambda.DeleteLayerVersionInput, _a2 ...request.Option) (*lambda.DeleteLayerVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteLayerVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteLayerVersionInput, ...request.Option) *lambda.DeleteLayerVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteLayerVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteLayerVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteProvisionedConcurrencyConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteProvisionedConcurrencyConfig(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.DeleteProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) *lambda.DeleteProvisionedConcurrencyConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteProvisionedConcurrencyConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) DeleteProvisionedConcurrencyConfigRequest(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.DeleteProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) *lambda.DeleteProvisionedConcurrencyConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.DeleteProvisionedConcurrencyConfigOutput)
		}
	}

	return r0, r1
}

// DeleteProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) DeleteProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.DeleteProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteProvisionedConcurrencyConfigInput, ...request.Option) *lambda.DeleteProvisionedConcurrencyConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.DeleteProvisionedConcurrencyConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteProvisionedConcurrencyConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountSettings provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetAccountSettings(_a0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetAccountSettingsOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetAccountSettingsInput) *lambda.GetAccountSettingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetAccountSettingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetAccountSettingsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountSettingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetAccountSettingsRequest(_a0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetAccountSettingsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetAccountSettingsOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetAccountSettingsInput) *lambda.GetAccountSettingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetAccountSettingsOutput)
		}
	}

	return r0, r1
}

// GetAccountSettingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetAccountSettingsWithContext(_a0 context.Context, _a1 *lambda.GetAccountSettingsInput, _a2 ...request.Option) (*lambda.GetAccountSettingsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetAccountSettingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetAccountSettingsInput, ...request.Option) *lambda.GetAccountSettingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetAccountSettingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetAccountSettingsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAlias provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetAlias(_a0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.AliasConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.GetAliasInput) *lambda.AliasConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AliasConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetAliasInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAliasRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetAliasRequest(_a0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetAliasInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.AliasConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.GetAliasInput) *lambda.AliasConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.AliasConfiguration)
		}
	}

	return r0, r1
}

// GetAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetAliasWithContext(_a0 context.Context, _a1 *lambda.GetAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.AliasConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetAliasInput, ...request.Option) *lambda.AliasConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AliasConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetAliasInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetCodeSigningConfig(_a0 *lambda.GetCodeSigningConfigInput) (*lambda.GetCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetCodeSigningConfigInput) *lambda.GetCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetCodeSigningConfigRequest(_a0 *lambda.GetCodeSigningConfigInput) (*request.Request, *lambda.GetCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetCodeSigningConfigInput) *lambda.GetCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// GetCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.GetCodeSigningConfigInput, _a2 ...request.Option) (*lambda.GetCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetCodeSigningConfigInput, ...request.Option) *lambda.GetCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEventSourceMapping provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetEventSourceMapping(_a0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.GetEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetEventSourceMappingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEventSourceMappingRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetEventSourceMappingRequest(_a0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetEventSourceMappingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.GetEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
		}
	}

	return r0, r1
}

// GetEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.GetEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetEventSourceMappingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunction provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunction(_a0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetFunctionOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionInput) *lambda.GetFunctionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionCodeSigningConfig(_a0 *lambda.GetFunctionCodeSigningConfigInput) (*lambda.GetFunctionCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionCodeSigningConfigInput) *lambda.GetFunctionCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionCodeSigningConfigRequest(_a0 *lambda.GetFunctionCodeSigningConfigInput) (*request.Request, *lambda.GetFunctionCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionCodeSigningConfigInput) *lambda.GetFunctionCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetFunctionCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// GetFunctionCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetFunctionCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.GetFunctionCodeSigningConfigInput, _a2 ...request.Option) (*lambda.GetFunctionCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionCodeSigningConfigInput, ...request.Option) *lambda.GetFunctionCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionConcurrency provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionConcurrency(_a0 *lambda.GetFunctionConcurrencyInput) (*lambda.GetFunctionConcurrencyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetFunctionConcurrencyOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConcurrencyInput) *lambda.GetFunctionConcurrencyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionConcurrencyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConcurrencyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionConcurrencyRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionConcurrencyRequest(_a0 *lambda.GetFunctionConcurrencyInput) (*request.Request, *lambda.GetFunctionConcurrencyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConcurrencyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetFunctionConcurrencyOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConcurrencyInput) *lambda.GetFunctionConcurrencyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetFunctionConcurrencyOutput)
		}
	}

	return r0, r1
}

// GetFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.GetFunctionConcurrencyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetFunctionConcurrencyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConcurrencyInput, ...request.Option) *lambda.GetFunctionConcurrencyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionConcurrencyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionConcurrencyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionConfiguration(_a0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConfigurationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionConfigurationRequest(_a0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.FunctionConfiguration)
		}
	}

	return r0, r1
}

// GetFunctionConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetFunctionConfigurationWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.Option) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionEventInvokeConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionEventInvokeConfig(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionEventInvokeConfigInput) *lambda.GetFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionEventInvokeConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionEventInvokeConfigRequest(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*request.Request, *lambda.GetFunctionEventInvokeConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionEventInvokeConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionEventInvokeConfigInput) *lambda.GetFunctionEventInvokeConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetFunctionEventInvokeConfigOutput)
		}
	}

	return r0, r1
}

// GetFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.GetFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionEventInvokeConfigInput, ...request.Option) *lambda.GetFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionEventInvokeConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFunctionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetFunctionRequest(_a0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetFunctionOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetFunctionInput) *lambda.GetFunctionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetFunctionOutput)
		}
	}

	return r0, r1
}

// GetFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetFunctionWithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.Option) (*lambda.GetFunctionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetFunctionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionInput, ...request.Option) *lambda.GetFunctionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetFunctionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLayerVersion provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetLayerVersion(_a0 *lambda.GetLayerVersionInput) (*lambda.GetLayerVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetLayerVersionOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionInput) *lambda.GetLayerVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetLayerVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLayerVersionByArn provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetLayerVersionByArn(_a0 *lambda.GetLayerVersionByArnInput) (*lambda.GetLayerVersionByArnOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetLayerVersionByArnOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionByArnInput) *lambda.GetLayerVersionByArnOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetLayerVersionByArnOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionByArnInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLayerVersionByArnRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetLayerVersionByArnRequest(_a0 *lambda.GetLayerVersionByArnInput) (*request.Request, *lambda.GetLayerVersionByArnOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionByArnInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetLayerVersionByArnOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionByArnInput) *lambda.GetLayerVersionByArnOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetLayerVersionByArnOutput)
		}
	}

	return r0, r1
}

// GetLayerVersionByArnWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetLayerVersionByArnWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionByArnInput, _a2 ...request.Option) (*lambda.GetLayerVersionByArnOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetLayerVersionByArnOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetLayerVersionByArnInput, ...request.Option) *lambda.GetLayerVersionByArnOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetLayerVersionByArnOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetLayerVersionByArnInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLayerVersionPolicy provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetLayerVersionPolicy(_a0 *lambda.GetLayerVersionPolicyInput) (*lambda.GetLayerVersionPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetLayerVersionPolicyOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionPolicyInput) *lambda.GetLayerVersionPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetLayerVersionPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLayerVersionPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetLayerVersionPolicyRequest(_a0 *lambda.GetLayerVersionPolicyInput) (*request.Request, *lambda.GetLayerVersionPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetLayerVersionPolicyOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionPolicyInput) *lambda.GetLayerVersionPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetLayerVersionPolicyOutput)
		}
	}

	return r0, r1
}

// GetLayerVersionPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetLayerVersionPolicyWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionPolicyInput, _a2 ...request.Option) (*lambda.GetLayerVersionPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetLayerVersionPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetLayerVersionPolicyInput, ...request.Option) *lambda.GetLayerVersionPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetLayerVersionPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetLayerVersionPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLayerVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetLayerVersionRequest(_a0 *lambda.GetLayerVersionInput) (*request.Request, *lambda.GetLayerVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetLayerVersionOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionInput) *lambda.GetLayerVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetLayerVersionOutput)
		}
	}

	return r0, r1
}

// GetLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetLayerVersionWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionInput, _a2 ...request.Option) (*lambda.GetLayerVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetLayerVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetLayerVersionInput, ...request.Option) *lambda.GetLayerVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetLayerVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetLayerVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicy provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetPolicy(_a0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetPolicyOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetPolicyInput) *lambda.GetPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetPolicyRequest(_a0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetPolicyOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetPolicyInput) *lambda.GetPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetPolicyOutput)
		}
	}

	return r0, r1
}

// GetPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetPolicyWithContext(_a0 context.Context, _a1 *lambda.GetPolicyInput, _a2 ...request.Option) (*lambda.GetPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetPolicyInput, ...request.Option) *lambda.GetPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetProvisionedConcurrencyConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetProvisionedConcurrencyConfig(_a0 *lambda.GetProvisionedConcurrencyConfigInput) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.GetProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.GetProvisionedConcurrencyConfigInput) *lambda.GetProvisionedConcurrencyConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetProvisionedConcurrencyConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.GetProvisionedConcurrencyConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) GetProvisionedConcurrencyConfigRequest(_a0 *lambda.GetProvisionedConcurrencyConfigInput) (*request.Request, *lambda.GetProvisionedConcurrencyConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.GetProvisionedConcurrencyConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.GetProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.GetProvisionedConcurrencyConfigInput) *lambda.GetProvisionedConcurrencyConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.GetProvisionedConcurrencyConfigOutput)
		}
	}

	return r0, r1
}

// GetProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) GetProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.GetProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.GetProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetProvisionedConcurrencyConfigInput, ...request.Option) *lambda.GetProvisionedConcurrencyConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.GetProvisionedConcurrencyConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetProvisionedConcurrencyConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Invoke provides a mock function with given fields: _a0
func (_m *MockFakeLambda) Invoke(_a0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.InvokeOutput
	if rf, ok := ret.Get(0).(func(*lambda.InvokeInput) *lambda.InvokeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.InvokeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.InvokeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// InvokeAsync provides a mock function with given fields: _a0
func (_m *MockFakeLambda) InvokeAsync(_a0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.InvokeAsyncOutput
	if rf, ok := ret.Get(0).(func(*lambda.InvokeAsyncInput) *lambda.InvokeAsyncOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.InvokeAsyncOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.InvokeAsyncInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// InvokeAsyncRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) InvokeAsyncRequest(_a0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.InvokeAsyncInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.InvokeAsyncOutput
	if rf, ok := ret.Get(1).(func(*lambda.InvokeAsyncInput) *lambda.InvokeAsyncOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.InvokeAsyncOutput)
		}
	}

	return r0, r1
}

// InvokeAsyncWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) InvokeAsyncWithContext(_a0 context.Context, _a1 *lambda.InvokeAsyncInput, _a2 ...request.Option) (*lambda.InvokeAsyncOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.InvokeAsyncOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.InvokeAsyncInput, ...request.Option) *lambda.InvokeAsyncOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.InvokeAsyncOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.InvokeAsyncInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// InvokeRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) InvokeRequest(_a0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.InvokeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.InvokeOutput
	if rf, ok := ret.Get(1).(func(*lambda.InvokeInput) *lambda.InvokeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.InvokeOutput)
		}
	}

	return r0, r1
}

// InvokeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) InvokeWithContext(_a0 context.Context, _a1 *lambda.InvokeInput, _a2 ...request.Option) (*lambda.InvokeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.InvokeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.InvokeInput, ...request.Option) *lambda.InvokeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.InvokeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.InvokeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAliases provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListAliases(_a0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListAliasesOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListAliasesInput) *lambda.ListAliasesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListAliasesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListAliasesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAliasesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListAliasesPages(_a0 *lambda.ListAliasesInput, _a1 func(*lambda.ListAliasesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListAliasesInput, func(*lambda.ListAliasesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAliasesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListAliasesPagesWithContext(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 func(*lambda.ListAliasesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListAliasesInput, func(*lambda.ListAliasesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAliasesRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListAliasesRequest(_a0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListAliasesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListAliasesOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListAliasesInput) *lambda.ListAliasesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListAliasesOutput)
		}
	}

	return r0, r1
}

// ListAliasesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListAliasesWithContext(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 ...request.Option) (*lambda.ListAliasesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListAliasesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListAliasesInput, ...request.Option) *lambda.ListAliasesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListAliasesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListAliasesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCodeSigningConfigs provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListCodeSigningConfigs(_a0 *lambda.ListCodeSigningConfigsInput) (*lambda.ListCodeSigningConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListCodeSigningConfigsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListCodeSigningConfigsInput) *lambda.ListCodeSigningConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListCodeSigningConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListCodeSigningConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCodeSigningConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListCodeSigningConfigsPages(_a0 *lambda.ListCodeSigningConfigsInput, _a1 func(*lambda.ListCodeSigningConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListCodeSigningConfigsInput, func(*lambda.ListCodeSigningConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCodeSigningConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListCodeSigningConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListCodeSigningConfigsInput, _a2 func(*lambda.ListCodeSigningConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListCodeSigningConfigsInput, func(*lambda.ListCodeSigningConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListCodeSigningConfigsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListCodeSigningConfigsRequest(_a0 *lambda.ListCodeSigningConfigsInput) (*request.Request, *lambda.ListCodeSigningConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListCodeSigningConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListCodeSigningConfigsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListCodeSigningConfigsInput) *lambda.ListCodeSigningConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListCodeSigningConfigsOutput)
		}
	}

	return r0, r1
}

// ListCodeSigningConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListCodeSigningConfigsWithContext(_a0 context.Context, _a1 *lambda.ListCodeSigningConfigsInput, _a2 ...request.Option) (*lambda.ListCodeSigningConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListCodeSigningConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListCodeSigningConfigsInput, ...request.Option) *lambda.ListCodeSigningConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListCodeSigningConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListCodeSigningConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEventSourceMappings provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListEventSourceMappings(_a0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListEventSourceMappingsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListEventSourceMappingsInput) *lambda.ListEventSourceMappingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListEventSourceMappingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListEventSourceMappingsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEventSourceMappingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListEventSourceMappingsPages(_a0 *lambda.ListEventSourceMappingsInput, _a1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListEventSourceMappingsInput, func(*lambda.ListEventSourceMappingsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEventSourceMappingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListEventSourceMappingsPagesWithContext(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 func(*lambda.ListEventSourceMappingsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListEventSourceMappingsInput, func(*lambda.ListEventSourceMappingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEventSourceMappingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListEventSourceMappingsRequest(_a0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListEventSourceMappingsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListEventSourceMappingsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListEventSourceMappingsInput) *lambda.ListEventSourceMappingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListEventSourceMappingsOutput)
		}
	}

	return r0, r1
}

// ListEventSourceMappingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListEventSourceMappingsWithContext(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListEventSourceMappingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListEventSourceMappingsInput, ...request.Option) *lambda.ListEventSourceMappingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListEventSourceMappingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListEventSourceMappingsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFunctionEventInvokeConfigs provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListFunctionEventInvokeConfigs(_a0 *lambda.ListFunctionEventInvokeConfigsInput) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListFunctionEventInvokeConfigsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionEventInvokeConfigsInput) *lambda.ListFunctionEventInvokeConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListFunctionEventInvokeConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListFunctionEventInvokeConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFunctionEventInvokeConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListFunctionEventInvokeConfigsPages(_a0 *lambda.ListFunctionEventInvokeConfigsInput, _a1 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionEventInvokeConfigsInput, func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFunctionEventInvokeConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListFunctionEventInvokeConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFunctionEventInvokeConfigsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListFunctionEventInvokeConfigsRequest(_a0 *lambda.ListFunctionEventInvokeConfigsInput) (*request.Request, *lambda.ListFunctionEventInvokeConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionEventInvokeConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListFunctionEventInvokeConfigsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListFunctionEventInvokeConfigsInput) *lambda.ListFunctionEventInvokeConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListFunctionEventInvokeConfigsOutput)
		}
	}

	return r0, r1
}

// ListFunctionEventInvokeConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListFunctionEventInvokeConfigsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListFunctionEventInvokeConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, ...request.Option) *lambda.ListFunctionEventInvokeConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListFunctionEventInvokeConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFunctions provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListFunctions(_a0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListFunctionsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsInput) *lambda.ListFunctionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListFunctionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListFunctionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFunctionsByCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListFunctionsByCodeSigningConfig(_a0 *lambda.ListFunctionsByCodeSigningConfigInput) (*lambda.ListFunctionsByCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListFunctionsByCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsByCodeSigningConfigInput) *lambda.ListFunctionsByCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListFunctionsByCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListFunctionsByCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFunctionsByCodeSigningConfigPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListFunctionsByCodeSigningConfigPages(_a0 *lambda.ListFunctionsByCodeSigningConfigInput, _a1 func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsByCodeSigningConfigInput, func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFunctionsByCodeSigningConfigPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListFunctionsByCodeSigningConfigPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsByCodeSigningConfigInput, _a2 func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionsByCodeSigningConfigInput, func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFunctionsByCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListFunctionsByCodeSigningConfigRequest(_a0 *lambda.ListFunctionsByCodeSigningConfigInput) (*request.Request, *lambda.ListFunctionsByCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsByCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListFunctionsByCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListFunctionsByCodeSigningConfigInput) *lambda.ListFunctionsByCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListFunctionsByCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// ListFunctionsByCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListFunctionsByCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsByCodeSigningConfigInput, _a2 ...request.Option) (*lambda.ListFunctionsByCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListFunctionsByCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionsByCodeSigningConfigInput, ...request.Option) *lambda.ListFunctionsByCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListFunctionsByCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListFunctionsByCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFunctionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListFunctionsPages(_a0 *lambda.ListFunctionsInput, _a1 func(*lambda.ListFunctionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsInput, func(*lambda.ListFunctionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFunctionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListFunctionsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 func(*lambda.ListFunctionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionsInput, func(*lambda.ListFunctionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFunctionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListFunctionsRequest(_a0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListFunctionsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListFunctionsInput) *lambda.ListFunctionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListFunctionsOutput)
		}
	}

	return r0, r1
}

// ListFunctionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListFunctionsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 ...request.Option) (*lambda.ListFunctionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListFunctionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionsInput, ...request.Option) *lambda.ListFunctionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListFunctionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListFunctionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLayerVersions provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListLayerVersions(_a0 *lambda.ListLayerVersionsInput) (*lambda.ListLayerVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListLayerVersionsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListLayerVersionsInput) *lambda.ListLayerVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListLayerVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListLayerVersionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLayerVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListLayerVersionsPages(_a0 *lambda.ListLayerVersionsInput, _a1 func(*lambda.ListLayerVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListLayerVersionsInput, func(*lambda.ListLayerVersionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLayerVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListLayerVersionsPagesWithContext(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 func(*lambda.ListLayerVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayerVersionsInput, func(*lambda.ListLayerVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLayerVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListLayerVersionsRequest(_a0 *lambda.ListLayerVersionsInput) (*request.Request, *lambda.ListLayerVersionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListLayerVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListLayerVersionsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListLayerVersionsInput) *lambda.ListLayerVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListLayerVersionsOutput)
		}
	}

	return r0, r1
}

// ListLayerVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListLayerVersionsWithContext(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 ...request.Option) (*lambda.ListLayerVersionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListLayerVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayerVersionsInput, ...request.Option) *lambda.ListLayerVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListLayerVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListLayerVersionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLayers provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListLayers(_a0 *lambda.ListLayersInput) (*lambda.ListLayersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListLayersOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListLayersInput) *lambda.ListLayersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListLayersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListLayersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListLayersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListLayersPages(_a0 *lambda.ListLayersInput, _a1 func(*lambda.ListLayersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListLayersInput, func(*lambda.ListLayersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLayersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListLayersPagesWithContext(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 func(*lambda.ListLayersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayersInput, func(*lambda.ListLayersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListLayersRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListLayersRequest(_a0 *lambda.ListLayersInput) (*request.Request, *lambda.ListLayersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListLayersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListLayersOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListLayersInput) *lambda.ListLayersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListLayersOutput)
		}
	}

	return r0, r1
}

// ListLayersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListLayersWithContext(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 ...request.Option) (*lambda.ListLayersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListLayersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayersInput, ...request.Option) *lambda.ListLayersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListLayersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListLayersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListProvisionedConcurrencyConfigs provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListProvisionedConcurrencyConfigs(_a0 *lambda.ListProvisionedConcurrencyConfigsInput) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListProvisionedConcurrencyConfigsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListProvisionedConcurrencyConfigsInput) *lambda.ListProvisionedConcurrencyConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListProvisionedConcurrencyConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListProvisionedConcurrencyConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListProvisionedConcurrencyConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListProvisionedConcurrencyConfigsPages(_a0 *lambda.ListProvisionedConcurrencyConfigsInput, _a1 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListProvisionedConcurrencyConfigsInput, func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListProvisionedConcurrencyConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListProvisionedConcurrencyConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListProvisionedConcurrencyConfigsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListProvisionedConcurrencyConfigsRequest(_a0 *lambda.ListProvisionedConcurrencyConfigsInput) (*request.Request, *lambda.ListProvisionedConcurrencyConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListProvisionedConcurrencyConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListProvisionedConcurrencyConfigsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListProvisionedConcurrencyConfigsInput) *lambda.ListProvisionedConcurrencyConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListProvisionedConcurrencyConfigsOutput)
		}
	}

	return r0, r1
}

// ListProvisionedConcurrencyConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListProvisionedConcurrencyConfigsWithContext(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 ...request.Option) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListProvisionedConcurrencyConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, ...request.Option) *lambda.ListProvisionedConcurrencyConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListProvisionedConcurrencyConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTags provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListTags(_a0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListTagsOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListTagsInput) *lambda.ListTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListTagsRequest(_a0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListTagsOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListTagsInput) *lambda.ListTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListTagsOutput)
		}
	}

	return r0, r1
}

// ListTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListTagsWithContext(_a0 context.Context, _a1 *lambda.ListTagsInput, _a2 ...request.Option) (*lambda.ListTagsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListTagsInput, ...request.Option) *lambda.ListTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListVersionsByFunction provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListVersionsByFunction(_a0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.ListVersionsByFunctionOutput
	if rf, ok := ret.Get(0).(func(*lambda.ListVersionsByFunctionInput) *lambda.ListVersionsByFunctionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListVersionsByFunctionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.ListVersionsByFunctionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListVersionsByFunctionPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeLambda) ListVersionsByFunctionPages(_a0 *lambda.ListVersionsByFunctionInput, _a1 func(*lambda.ListVersionsByFunctionOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.ListVersionsByFunctionInput, func(*lambda.ListVersionsByFunctionOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListVersionsByFunctionPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeLambda) ListVersionsByFunctionPagesWithContext(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 func(*lambda.ListVersionsByFunctionOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListVersionsByFunctionInput, func(*lambda.ListVersionsByFunctionOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListVersionsByFunctionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) ListVersionsByFunctionRequest(_a0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.ListVersionsByFunctionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.ListVersionsByFunctionOutput
	if rf, ok := ret.Get(1).(func(*lambda.ListVersionsByFunctionInput) *lambda.ListVersionsByFunctionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.ListVersionsByFunctionOutput)
		}
	}

	return r0, r1
}

// ListVersionsByFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) ListVersionsByFunctionWithContext(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.ListVersionsByFunctionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListVersionsByFunctionInput, ...request.Option) *lambda.ListVersionsByFunctionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.ListVersionsByFunctionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListVersionsByFunctionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PublishLayerVersion provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PublishLayerVersion(_a0 *lambda.PublishLayerVersionInput) (*lambda.PublishLayerVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.PublishLayerVersionOutput
	if rf, ok := ret.Get(0).(func(*lambda.PublishLayerVersionInput) *lambda.PublishLayerVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PublishLayerVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.PublishLayerVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PublishLayerVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PublishLayerVersionRequest(_a0 *lambda.PublishLayerVersionInput) (*request.Request, *lambda.PublishLayerVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.PublishLayerVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.PublishLayerVersionOutput
	if rf, ok := ret.Get(1).(func(*lambda.PublishLayerVersionInput) *lambda.PublishLayerVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.PublishLayerVersionOutput)
		}
	}

	return r0, r1
}

// PublishLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) PublishLayerVersionWithContext(_a0 context.Context, _a1 *lambda.PublishLayerVersionInput, _a2 ...request.Option) (*lambda.PublishLayerVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.PublishLayerVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.PublishLayerVersionInput, ...request.Option) *lambda.PublishLayerVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PublishLayerVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.PublishLayerVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PublishVersion provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PublishVersion(_a0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.PublishVersionInput) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.PublishVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PublishVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PublishVersionRequest(_a0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.PublishVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.PublishVersionInput) *lambda.FunctionConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.FunctionConfiguration)
		}
	}

	return r0, r1
}

// PublishVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) PublishVersionWithContext(_a0 context.Context, _a1 *lambda.PublishVersionInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.PublishVersionInput, ...request.Option) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.PublishVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutFunctionCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutFunctionCodeSigningConfig(_a0 *lambda.PutFunctionCodeSigningConfigInput) (*lambda.PutFunctionCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.PutFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.PutFunctionCodeSigningConfigInput) *lambda.PutFunctionCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutFunctionCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.PutFunctionCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutFunctionCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutFunctionCodeSigningConfigRequest(_a0 *lambda.PutFunctionCodeSigningConfigInput) (*request.Request, *lambda.PutFunctionCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.PutFunctionCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.PutFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.PutFunctionCodeSigningConfigInput) *lambda.PutFunctionCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.PutFunctionCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// PutFunctionCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) PutFunctionCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.PutFunctionCodeSigningConfigInput, _a2 ...request.Option) (*lambda.PutFunctionCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.PutFunctionCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutFunctionCodeSigningConfigInput, ...request.Option) *lambda.PutFunctionCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutFunctionCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutFunctionCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutFunctionConcurrency provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutFunctionConcurrency(_a0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.PutFunctionConcurrencyOutput
	if rf, ok := ret.Get(0).(func(*lambda.PutFunctionConcurrencyInput) *lambda.PutFunctionConcurrencyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutFunctionConcurrencyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.PutFunctionConcurrencyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutFunctionConcurrencyRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutFunctionConcurrencyRequest(_a0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.PutFunctionConcurrencyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.PutFunctionConcurrencyOutput
	if rf, ok := ret.Get(1).(func(*lambda.PutFunctionConcurrencyInput) *lambda.PutFunctionConcurrencyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.PutFunctionConcurrencyOutput)
		}
	}

	return r0, r1
}

// PutFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) PutFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.PutFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.PutFunctionConcurrencyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutFunctionConcurrencyInput, ...request.Option) *lambda.PutFunctionConcurrencyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutFunctionConcurrencyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutFunctionConcurrencyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutFunctionEventInvokeConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutFunctionEventInvokeConfig(_a0 *lambda.PutFunctionEventInvokeConfigInput) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.PutFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.PutFunctionEventInvokeConfigInput) *lambda.PutFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.PutFunctionEventInvokeConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutFunctionEventInvokeConfigRequest(_a0 *lambda.PutFunctionEventInvokeConfigInput) (*request.Request, *lambda.PutFunctionEventInvokeConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.PutFunctionEventInvokeConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.PutFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.PutFunctionEventInvokeConfigInput) *lambda.PutFunctionEventInvokeConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.PutFunctionEventInvokeConfigOutput)
		}
	}

	return r0, r1
}

// PutFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) PutFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.PutFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.PutFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutFunctionEventInvokeConfigInput, ...request.Option) *lambda.PutFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutFunctionEventInvokeConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutProvisionedConcurrencyConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutProvisionedConcurrencyConfig(_a0 *lambda.PutProvisionedConcurrencyConfigInput) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.PutProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.PutProvisionedConcurrencyConfigInput) *lambda.PutProvisionedConcurrencyConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutProvisionedConcurrencyConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.PutProvisionedConcurrencyConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) PutProvisionedConcurrencyConfigRequest(_a0 *lambda.PutProvisionedConcurrencyConfigInput) (*request.Request, *lambda.PutProvisionedConcurrencyConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.PutProvisionedConcurrencyConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.PutProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.PutProvisionedConcurrencyConfigInput) *lambda.PutProvisionedConcurrencyConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.PutProvisionedConcurrencyConfigOutput)
		}
	}

	return r0, r1
}

// PutProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) PutProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.PutProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.PutProvisionedConcurrencyConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutProvisionedConcurrencyConfigInput, ...request.Option) *lambda.PutProvisionedConcurrencyConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.PutProvisionedConcurrencyConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutProvisionedConcurrencyConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveLayerVersionPermission provides a mock function with given fields: _a0
func (_m *MockFakeLambda) RemoveLayerVersionPermission(_a0 *lambda.RemoveLayerVersionPermissionInput) (*lambda.RemoveLayerVersionPermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.RemoveLayerVersionPermissionOutput
	if rf, ok := ret.Get(0).(func(*lambda.RemoveLayerVersionPermissionInput) *lambda.RemoveLayerVersionPermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.RemoveLayerVersionPermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.RemoveLayerVersionPermissionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveLayerVersionPermissionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) RemoveLayerVersionPermissionRequest(_a0 *lambda.RemoveLayerVersionPermissionInput) (*request.Request, *lambda.RemoveLayerVersionPermissionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.RemoveLayerVersionPermissionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.RemoveLayerVersionPermissionOutput
	if rf, ok := ret.Get(1).(func(*lambda.RemoveLayerVersionPermissionInput) *lambda.RemoveLayerVersionPermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.RemoveLayerVersionPermissionOutput)
		}
	}

	return r0, r1
}

// RemoveLayerVersionPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) RemoveLayerVersionPermissionWithContext(_a0 context.Context, _a1 *lambda.RemoveLayerVersionPermissionInput, _a2 ...request.Option) (*lambda.RemoveLayerVersionPermissionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.RemoveLayerVersionPermissionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.RemoveLayerVersionPermissionInput, ...request.Option) *lambda.RemoveLayerVersionPermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.RemoveLayerVersionPermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.RemoveLayerVersionPermissionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemovePermission provides a mock function with given fields: _a0
func (_m *MockFakeLambda) RemovePermission(_a0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.RemovePermissionOutput
	if rf, ok := ret.Get(0).(func(*lambda.RemovePermissionInput) *lambda.RemovePermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.RemovePermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.RemovePermissionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemovePermissionRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) RemovePermissionRequest(_a0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.RemovePermissionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.RemovePermissionOutput
	if rf, ok := ret.Get(1).(func(*lambda.RemovePermissionInput) *lambda.RemovePermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.RemovePermissionOutput)
		}
	}

	return r0, r1
}

// RemovePermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) RemovePermissionWithContext(_a0 context.Context, _a1 *lambda.RemovePermissionInput, _a2 ...request.Option) (*lambda.RemovePermissionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.RemovePermissionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.RemovePermissionInput, ...request.Option) *lambda.RemovePermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.RemovePermissionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.RemovePermissionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResource provides a mock function with given fields: _a0
func (_m *MockFakeLambda) TagResource(_a0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.TagResourceOutput
	if rf, ok := ret.Get(0).(func(*lambda.TagResourceInput) *lambda.TagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.TagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) TagResourceRequest(_a0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.TagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.TagResourceOutput
	if rf, ok := ret.Get(1).(func(*lambda.TagResourceInput) *lambda.TagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.TagResourceOutput)
		}
	}

	return r0, r1
}

// TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) TagResourceWithContext(_a0 context.Context, _a1 *lambda.TagResourceInput, _a2 ...request.Option) (*lambda.TagResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.TagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.TagResourceInput, ...request.Option) *lambda.TagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.TagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResource provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UntagResource(_a0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(*lambda.UntagResourceInput) *lambda.UntagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UntagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UntagResourceRequest(_a0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UntagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.UntagResourceOutput
	if rf, ok := ret.Get(1).(func(*lambda.UntagResourceInput) *lambda.UntagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.UntagResourceOutput)
		}
	}

	return r0, r1
}

// UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UntagResourceWithContext(_a0 context.Context, _a1 *lambda.UntagResourceInput, _a2 ...request.Option) (*lambda.UntagResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UntagResourceInput, ...request.Option) *lambda.UntagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UntagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAlias provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateAlias(_a0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.AliasConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.UpdateAliasInput) *lambda.AliasConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AliasConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UpdateAliasInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAliasRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateAliasRequest(_a0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UpdateAliasInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.AliasConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.UpdateAliasInput) *lambda.AliasConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.AliasConfiguration)
		}
	}

	return r0, r1
}

// UpdateAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UpdateAliasWithContext(_a0 context.Context, _a1 *lambda.UpdateAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.AliasConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateAliasInput, ...request.Option) *lambda.AliasConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.AliasConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateAliasInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateCodeSigningConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateCodeSigningConfig(_a0 *lambda.UpdateCodeSigningConfigInput) (*lambda.UpdateCodeSigningConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.UpdateCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.UpdateCodeSigningConfigInput) *lambda.UpdateCodeSigningConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.UpdateCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UpdateCodeSigningConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateCodeSigningConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateCodeSigningConfigRequest(_a0 *lambda.UpdateCodeSigningConfigInput) (*request.Request, *lambda.UpdateCodeSigningConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UpdateCodeSigningConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.UpdateCodeSigningConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.UpdateCodeSigningConfigInput) *lambda.UpdateCodeSigningConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.UpdateCodeSigningConfigOutput)
		}
	}

	return r0, r1
}

// UpdateCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UpdateCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.UpdateCodeSigningConfigInput, _a2 ...request.Option) (*lambda.UpdateCodeSigningConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.UpdateCodeSigningConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateCodeSigningConfigInput, ...request.Option) *lambda.UpdateCodeSigningConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.UpdateCodeSigningConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateCodeSigningConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEventSourceMapping provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateEventSourceMapping(_a0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.UpdateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UpdateEventSourceMappingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEventSourceMappingRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateEventSourceMappingRequest(_a0 *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UpdateEventSourceMappingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.UpdateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
		}
	}

	return r0, r1
}

// UpdateEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UpdateEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.UpdateEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.EventSourceMappingConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateEventSourceMappingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateFunctionCode provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateFunctionCode(_a0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionCodeInput) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionCodeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateFunctionCodeRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateFunctionCodeRequest(_a0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionCodeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionCodeInput) *lambda.FunctionConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.FunctionConfiguration)
		}
	}

	return r0, r1
}

// UpdateFunctionCodeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UpdateFunctionCodeWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionCodeInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateFunctionCodeInput, ...request.Option) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateFunctionCodeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateFunctionConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateFunctionConfiguration(_a0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionConfigurationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateFunctionConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateFunctionConfigurationRequest(_a0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionConfigurationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.FunctionConfiguration)
		}
	}

	return r0, r1
}

// UpdateFunctionConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UpdateFunctionConfigurationWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionConfigurationInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.FunctionConfiguration
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateFunctionConfigurationInput, ...request.Option) *lambda.FunctionConfiguration); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.FunctionConfiguration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateFunctionConfigurationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateFunctionEventInvokeConfig provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateFunctionEventInvokeConfig(_a0 *lambda.UpdateFunctionEventInvokeConfigInput) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *lambda.UpdateFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionEventInvokeConfigInput) *lambda.UpdateFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.UpdateFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionEventInvokeConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
func (_m *MockFakeLambda) UpdateFunctionEventInvokeConfigRequest(_a0 *lambda.UpdateFunctionEventInvokeConfigInput) (*request.Request, *lambda.UpdateFunctionEventInvokeConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionEventInvokeConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *lambda.UpdateFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionEventInvokeConfigInput) *lambda.UpdateFunctionEventInvokeConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*lambda.UpdateFunctionEventInvokeConfigOutput)
		}
	}

	return r0, r1
}

// UpdateFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) UpdateFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *lambda.UpdateFunctionEventInvokeConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateFunctionEventInvokeConfigInput, ...request.Option) *lambda.UpdateFunctionEventInvokeConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lambda.UpdateFunctionEventInvokeConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateFunctionEventInvokeConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilFunctionActive provides a mock function with given fields: _a0
func (_m *MockFakeLambda) WaitUntilFunctionActive(_a0 *lambda.GetFunctionConfigurationInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFunctionActiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) WaitUntilFunctionActiveWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFunctionExists provides a mock function with given fields: _a0
func (_m *MockFakeLambda) WaitUntilFunctionExists(_a0 *lambda.GetFunctionInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFunctionExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) WaitUntilFunctionExistsWithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFunctionUpdated provides a mock function with given fields: _a0
func (_m *MockFakeLambda) WaitUntilFunctionUpdated(_a0 *lambda.GetFunctionConfigurationInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFunctionUpdatedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeLambda) WaitUntilFunctionUpdatedWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}