// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/lambda/lambdaiface (interfaces: LambdaAPI)

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

import (
	context "context"
	reflect "reflect"

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

// MockLambdaAPI is a mock of LambdaAPI interface
type MockLambdaAPI struct {
	ctrl     *gomock.Controller
	recorder *MockLambdaAPIMockRecorder
}

// MockLambdaAPIMockRecorder is the mock recorder for MockLambdaAPI
type MockLambdaAPIMockRecorder struct {
	mock *MockLambdaAPI
}

// NewMockLambdaAPI creates a new mock instance
func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
	mock := &MockLambdaAPI{ctrl: ctrl}
	mock.recorder = &MockLambdaAPIMockRecorder{mock}
	return mock
}

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

// AddLayerVersionPermission mocks base method
func (m *MockLambdaAPI) AddLayerVersionPermission(arg0 *lambda.AddLayerVersionPermissionInput) (*lambda.AddLayerVersionPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLayerVersionPermission", arg0)
	ret0, _ := ret[0].(*lambda.AddLayerVersionPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddLayerVersionPermissionRequest mocks base method
func (m *MockLambdaAPI) AddLayerVersionPermissionRequest(arg0 *lambda.AddLayerVersionPermissionInput) (*request.Request, *lambda.AddLayerVersionPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLayerVersionPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.AddLayerVersionPermissionOutput)
	return ret0, ret1
}

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

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

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

// AddPermission mocks base method
func (m *MockLambdaAPI) AddPermission(arg0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPermission", arg0)
	ret0, _ := ret[0].(*lambda.AddPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddPermissionRequest mocks base method
func (m *MockLambdaAPI) AddPermissionRequest(arg0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.AddPermissionOutput)
	return ret0, ret1
}

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

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

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

// CreateAlias mocks base method
func (m *MockLambdaAPI) CreateAlias(arg0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAlias", arg0)
	ret0, _ := ret[0].(*lambda.AliasConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAliasRequest mocks base method
func (m *MockLambdaAPI) CreateAliasRequest(arg0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.AliasConfiguration)
	return ret0, ret1
}

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

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

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

// CreateEventSourceMapping mocks base method
func (m *MockLambdaAPI) CreateEventSourceMapping(arg0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEventSourceMapping", arg0)
	ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEventSourceMappingRequest mocks base method
func (m *MockLambdaAPI) CreateEventSourceMappingRequest(arg0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEventSourceMappingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
	return ret0, ret1
}

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

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

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

// CreateFunction mocks base method
func (m *MockLambdaAPI) CreateFunction(arg0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFunction", arg0)
	ret0, _ := ret[0].(*lambda.FunctionConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFunctionRequest mocks base method
func (m *MockLambdaAPI) CreateFunctionRequest(arg0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFunctionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.FunctionConfiguration)
	return ret0, ret1
}

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

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

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

// DeleteAlias mocks base method
func (m *MockLambdaAPI) DeleteAlias(arg0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlias", arg0)
	ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAliasRequest mocks base method
func (m *MockLambdaAPI) DeleteAliasRequest(arg0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.DeleteAliasOutput)
	return ret0, ret1
}

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

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

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

// DeleteEventSourceMapping mocks base method
func (m *MockLambdaAPI) DeleteEventSourceMapping(arg0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEventSourceMapping", arg0)
	ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEventSourceMappingRequest mocks base method
func (m *MockLambdaAPI) DeleteEventSourceMappingRequest(arg0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEventSourceMappingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
	return ret0, ret1
}

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

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

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

// DeleteFunction mocks base method
func (m *MockLambdaAPI) DeleteFunction(arg0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFunction", arg0)
	ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFunctionConcurrency mocks base method
func (m *MockLambdaAPI) DeleteFunctionConcurrency(arg0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFunctionConcurrency", arg0)
	ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFunctionConcurrencyRequest mocks base method
func (m *MockLambdaAPI) DeleteFunctionConcurrencyRequest(arg0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.DeleteFunctionConcurrencyOutput)
	return ret0, ret1
}

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

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

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

// DeleteFunctionEventInvokeConfig mocks base method
func (m *MockLambdaAPI) DeleteFunctionEventInvokeConfig(arg0 *lambda.DeleteFunctionEventInvokeConfigInput) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFunctionEventInvokeConfig", arg0)
	ret0, _ := ret[0].(*lambda.DeleteFunctionEventInvokeConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFunctionEventInvokeConfigRequest mocks base method
func (m *MockLambdaAPI) DeleteFunctionEventInvokeConfigRequest(arg0 *lambda.DeleteFunctionEventInvokeConfigInput) (*request.Request, *lambda.DeleteFunctionEventInvokeConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFunctionEventInvokeConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.DeleteFunctionEventInvokeConfigOutput)
	return ret0, ret1
}

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

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

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

// DeleteFunctionRequest mocks base method
func (m *MockLambdaAPI) DeleteFunctionRequest(arg0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFunctionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.DeleteFunctionOutput)
	return ret0, ret1
}

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

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

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

// DeleteLayerVersion mocks base method
func (m *MockLambdaAPI) DeleteLayerVersion(arg0 *lambda.DeleteLayerVersionInput) (*lambda.DeleteLayerVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLayerVersion", arg0)
	ret0, _ := ret[0].(*lambda.DeleteLayerVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLayerVersionRequest mocks base method
func (m *MockLambdaAPI) DeleteLayerVersionRequest(arg0 *lambda.DeleteLayerVersionInput) (*request.Request, *lambda.DeleteLayerVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLayerVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.DeleteLayerVersionOutput)
	return ret0, ret1
}

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

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

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

// DeleteProvisionedConcurrencyConfig mocks base method
func (m *MockLambdaAPI) DeleteProvisionedConcurrencyConfig(arg0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProvisionedConcurrencyConfig", arg0)
	ret0, _ := ret[0].(*lambda.DeleteProvisionedConcurrencyConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteProvisionedConcurrencyConfigRequest mocks base method
func (m *MockLambdaAPI) DeleteProvisionedConcurrencyConfigRequest(arg0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProvisionedConcurrencyConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.DeleteProvisionedConcurrencyConfigOutput)
	return ret0, ret1
}

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

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

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

// GetAccountSettings mocks base method
func (m *MockLambdaAPI) GetAccountSettings(arg0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountSettings", arg0)
	ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountSettingsRequest mocks base method
func (m *MockLambdaAPI) GetAccountSettingsRequest(arg0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetAccountSettingsOutput)
	return ret0, ret1
}

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

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

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

// GetAlias mocks base method
func (m *MockLambdaAPI) GetAlias(arg0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAlias", arg0)
	ret0, _ := ret[0].(*lambda.AliasConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAliasRequest mocks base method
func (m *MockLambdaAPI) GetAliasRequest(arg0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.AliasConfiguration)
	return ret0, ret1
}

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

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

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

// GetEventSourceMapping mocks base method
func (m *MockLambdaAPI) GetEventSourceMapping(arg0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventSourceMapping", arg0)
	ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEventSourceMappingRequest mocks base method
func (m *MockLambdaAPI) GetEventSourceMappingRequest(arg0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventSourceMappingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
	return ret0, ret1
}

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

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

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

// GetFunction mocks base method
func (m *MockLambdaAPI) GetFunction(arg0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunction", arg0)
	ret0, _ := ret[0].(*lambda.GetFunctionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFunctionConcurrency mocks base method
func (m *MockLambdaAPI) GetFunctionConcurrency(arg0 *lambda.GetFunctionConcurrencyInput) (*lambda.GetFunctionConcurrencyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionConcurrency", arg0)
	ret0, _ := ret[0].(*lambda.GetFunctionConcurrencyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFunctionConcurrencyRequest mocks base method
func (m *MockLambdaAPI) GetFunctionConcurrencyRequest(arg0 *lambda.GetFunctionConcurrencyInput) (*request.Request, *lambda.GetFunctionConcurrencyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionConcurrencyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetFunctionConcurrencyOutput)
	return ret0, ret1
}

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

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

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

// GetFunctionConfiguration mocks base method
func (m *MockLambdaAPI) GetFunctionConfiguration(arg0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionConfiguration", arg0)
	ret0, _ := ret[0].(*lambda.FunctionConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFunctionConfigurationRequest mocks base method
func (m *MockLambdaAPI) GetFunctionConfigurationRequest(arg0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.FunctionConfiguration)
	return ret0, ret1
}

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

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

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

// GetFunctionEventInvokeConfig mocks base method
func (m *MockLambdaAPI) GetFunctionEventInvokeConfig(arg0 *lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionEventInvokeConfig", arg0)
	ret0, _ := ret[0].(*lambda.GetFunctionEventInvokeConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFunctionEventInvokeConfigRequest mocks base method
func (m *MockLambdaAPI) GetFunctionEventInvokeConfigRequest(arg0 *lambda.GetFunctionEventInvokeConfigInput) (*request.Request, *lambda.GetFunctionEventInvokeConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionEventInvokeConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetFunctionEventInvokeConfigOutput)
	return ret0, ret1
}

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

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

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

// GetFunctionRequest mocks base method
func (m *MockLambdaAPI) GetFunctionRequest(arg0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFunctionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetFunctionOutput)
	return ret0, ret1
}

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

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

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

// GetLayerVersion mocks base method
func (m *MockLambdaAPI) GetLayerVersion(arg0 *lambda.GetLayerVersionInput) (*lambda.GetLayerVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerVersion", arg0)
	ret0, _ := ret[0].(*lambda.GetLayerVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLayerVersionByArn mocks base method
func (m *MockLambdaAPI) GetLayerVersionByArn(arg0 *lambda.GetLayerVersionByArnInput) (*lambda.GetLayerVersionByArnOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerVersionByArn", arg0)
	ret0, _ := ret[0].(*lambda.GetLayerVersionByArnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLayerVersionByArnRequest mocks base method
func (m *MockLambdaAPI) GetLayerVersionByArnRequest(arg0 *lambda.GetLayerVersionByArnInput) (*request.Request, *lambda.GetLayerVersionByArnOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerVersionByArnRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetLayerVersionByArnOutput)
	return ret0, ret1
}

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

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

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

// GetLayerVersionPolicy mocks base method
func (m *MockLambdaAPI) GetLayerVersionPolicy(arg0 *lambda.GetLayerVersionPolicyInput) (*lambda.GetLayerVersionPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerVersionPolicy", arg0)
	ret0, _ := ret[0].(*lambda.GetLayerVersionPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLayerVersionPolicyRequest mocks base method
func (m *MockLambdaAPI) GetLayerVersionPolicyRequest(arg0 *lambda.GetLayerVersionPolicyInput) (*request.Request, *lambda.GetLayerVersionPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerVersionPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetLayerVersionPolicyOutput)
	return ret0, ret1
}

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

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

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

// GetLayerVersionRequest mocks base method
func (m *MockLambdaAPI) GetLayerVersionRequest(arg0 *lambda.GetLayerVersionInput) (*request.Request, *lambda.GetLayerVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetLayerVersionOutput)
	return ret0, ret1
}

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

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

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

// GetPolicy mocks base method
func (m *MockLambdaAPI) GetPolicy(arg0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicy", arg0)
	ret0, _ := ret[0].(*lambda.GetPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPolicyRequest mocks base method
func (m *MockLambdaAPI) GetPolicyRequest(arg0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetPolicyOutput)
	return ret0, ret1
}

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

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

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

// GetProvisionedConcurrencyConfig mocks base method
func (m *MockLambdaAPI) GetProvisionedConcurrencyConfig(arg0 *lambda.GetProvisionedConcurrencyConfigInput) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionedConcurrencyConfig", arg0)
	ret0, _ := ret[0].(*lambda.GetProvisionedConcurrencyConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProvisionedConcurrencyConfigRequest mocks base method
func (m *MockLambdaAPI) GetProvisionedConcurrencyConfigRequest(arg0 *lambda.GetProvisionedConcurrencyConfigInput) (*request.Request, *lambda.GetProvisionedConcurrencyConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionedConcurrencyConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.GetProvisionedConcurrencyConfigOutput)
	return ret0, ret1
}

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

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

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

// Invoke mocks base method
func (m *MockLambdaAPI) Invoke(arg0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Invoke", arg0)
	ret0, _ := ret[0].(*lambda.InvokeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InvokeAsync mocks base method
func (m *MockLambdaAPI) InvokeAsync(arg0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvokeAsync", arg0)
	ret0, _ := ret[0].(*lambda.InvokeAsyncOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InvokeAsyncRequest mocks base method
func (m *MockLambdaAPI) InvokeAsyncRequest(arg0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvokeAsyncRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.InvokeAsyncOutput)
	return ret0, ret1
}

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

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

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

// InvokeRequest mocks base method
func (m *MockLambdaAPI) InvokeRequest(arg0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvokeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.InvokeOutput)
	return ret0, ret1
}

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

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

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

// ListAliases mocks base method
func (m *MockLambdaAPI) ListAliases(arg0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliases", arg0)
	ret0, _ := ret[0].(*lambda.ListAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAliasesPages mocks base method
func (m *MockLambdaAPI) ListAliasesPages(arg0 *lambda.ListAliasesInput, arg1 func(*lambda.ListAliasesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListAliasesRequest mocks base method
func (m *MockLambdaAPI) ListAliasesRequest(arg0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListAliasesOutput)
	return ret0, ret1
}

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

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

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

// ListEventSourceMappings mocks base method
func (m *MockLambdaAPI) ListEventSourceMappings(arg0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventSourceMappings", arg0)
	ret0, _ := ret[0].(*lambda.ListEventSourceMappingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEventSourceMappingsPages mocks base method
func (m *MockLambdaAPI) ListEventSourceMappingsPages(arg0 *lambda.ListEventSourceMappingsInput, arg1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventSourceMappingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListEventSourceMappingsRequest mocks base method
func (m *MockLambdaAPI) ListEventSourceMappingsRequest(arg0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventSourceMappingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListEventSourceMappingsOutput)
	return ret0, ret1
}

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

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

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

// ListFunctionEventInvokeConfigs mocks base method
func (m *MockLambdaAPI) ListFunctionEventInvokeConfigs(arg0 *lambda.ListFunctionEventInvokeConfigsInput) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFunctionEventInvokeConfigs", arg0)
	ret0, _ := ret[0].(*lambda.ListFunctionEventInvokeConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFunctionEventInvokeConfigsPages mocks base method
func (m *MockLambdaAPI) ListFunctionEventInvokeConfigsPages(arg0 *lambda.ListFunctionEventInvokeConfigsInput, arg1 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFunctionEventInvokeConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListFunctionEventInvokeConfigsRequest mocks base method
func (m *MockLambdaAPI) ListFunctionEventInvokeConfigsRequest(arg0 *lambda.ListFunctionEventInvokeConfigsInput) (*request.Request, *lambda.ListFunctionEventInvokeConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFunctionEventInvokeConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListFunctionEventInvokeConfigsOutput)
	return ret0, ret1
}

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

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

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

// ListFunctions mocks base method
func (m *MockLambdaAPI) ListFunctions(arg0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFunctions", arg0)
	ret0, _ := ret[0].(*lambda.ListFunctionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFunctionsPages mocks base method
func (m *MockLambdaAPI) ListFunctionsPages(arg0 *lambda.ListFunctionsInput, arg1 func(*lambda.ListFunctionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFunctionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListFunctionsRequest mocks base method
func (m *MockLambdaAPI) ListFunctionsRequest(arg0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFunctionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListFunctionsOutput)
	return ret0, ret1
}

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

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

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

// ListLayerVersions mocks base method
func (m *MockLambdaAPI) ListLayerVersions(arg0 *lambda.ListLayerVersionsInput) (*lambda.ListLayerVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLayerVersions", arg0)
	ret0, _ := ret[0].(*lambda.ListLayerVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLayerVersionsPages mocks base method
func (m *MockLambdaAPI) ListLayerVersionsPages(arg0 *lambda.ListLayerVersionsInput, arg1 func(*lambda.ListLayerVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLayerVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListLayerVersionsRequest mocks base method
func (m *MockLambdaAPI) ListLayerVersionsRequest(arg0 *lambda.ListLayerVersionsInput) (*request.Request, *lambda.ListLayerVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLayerVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListLayerVersionsOutput)
	return ret0, ret1
}

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

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

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

// ListLayers mocks base method
func (m *MockLambdaAPI) ListLayers(arg0 *lambda.ListLayersInput) (*lambda.ListLayersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLayers", arg0)
	ret0, _ := ret[0].(*lambda.ListLayersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLayersPages mocks base method
func (m *MockLambdaAPI) ListLayersPages(arg0 *lambda.ListLayersInput, arg1 func(*lambda.ListLayersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLayersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListLayersRequest mocks base method
func (m *MockLambdaAPI) ListLayersRequest(arg0 *lambda.ListLayersInput) (*request.Request, *lambda.ListLayersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLayersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListLayersOutput)
	return ret0, ret1
}

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

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

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

// ListProvisionedConcurrencyConfigs mocks base method
func (m *MockLambdaAPI) ListProvisionedConcurrencyConfigs(arg0 *lambda.ListProvisionedConcurrencyConfigsInput) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProvisionedConcurrencyConfigs", arg0)
	ret0, _ := ret[0].(*lambda.ListProvisionedConcurrencyConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListProvisionedConcurrencyConfigsPages mocks base method
func (m *MockLambdaAPI) ListProvisionedConcurrencyConfigsPages(arg0 *lambda.ListProvisionedConcurrencyConfigsInput, arg1 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProvisionedConcurrencyConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListProvisionedConcurrencyConfigsRequest mocks base method
func (m *MockLambdaAPI) ListProvisionedConcurrencyConfigsRequest(arg0 *lambda.ListProvisionedConcurrencyConfigsInput) (*request.Request, *lambda.ListProvisionedConcurrencyConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProvisionedConcurrencyConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListProvisionedConcurrencyConfigsOutput)
	return ret0, ret1
}

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

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

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

// ListTags mocks base method
func (m *MockLambdaAPI) ListTags(arg0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", arg0)
	ret0, _ := ret[0].(*lambda.ListTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsRequest mocks base method
func (m *MockLambdaAPI) ListTagsRequest(arg0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListTagsOutput)
	return ret0, ret1
}

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

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

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

// ListVersionsByFunction mocks base method
func (m *MockLambdaAPI) ListVersionsByFunction(arg0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVersionsByFunction", arg0)
	ret0, _ := ret[0].(*lambda.ListVersionsByFunctionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVersionsByFunctionPages mocks base method
func (m *MockLambdaAPI) ListVersionsByFunctionPages(arg0 *lambda.ListVersionsByFunctionInput, arg1 func(*lambda.ListVersionsByFunctionOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVersionsByFunctionPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ListVersionsByFunctionRequest mocks base method
func (m *MockLambdaAPI) ListVersionsByFunctionRequest(arg0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVersionsByFunctionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.ListVersionsByFunctionOutput)
	return ret0, ret1
}

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

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

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

// PublishLayerVersion mocks base method
func (m *MockLambdaAPI) PublishLayerVersion(arg0 *lambda.PublishLayerVersionInput) (*lambda.PublishLayerVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishLayerVersion", arg0)
	ret0, _ := ret[0].(*lambda.PublishLayerVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PublishLayerVersionRequest mocks base method
func (m *MockLambdaAPI) PublishLayerVersionRequest(arg0 *lambda.PublishLayerVersionInput) (*request.Request, *lambda.PublishLayerVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishLayerVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.PublishLayerVersionOutput)
	return ret0, ret1
}

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

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

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

// PublishVersion mocks base method
func (m *MockLambdaAPI) PublishVersion(arg0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishVersion", arg0)
	ret0, _ := ret[0].(*lambda.FunctionConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PublishVersionRequest mocks base method
func (m *MockLambdaAPI) PublishVersionRequest(arg0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.FunctionConfiguration)
	return ret0, ret1
}

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

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

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

// PutFunctionConcurrency mocks base method
func (m *MockLambdaAPI) PutFunctionConcurrency(arg0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutFunctionConcurrency", arg0)
	ret0, _ := ret[0].(*lambda.PutFunctionConcurrencyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutFunctionConcurrencyRequest mocks base method
func (m *MockLambdaAPI) PutFunctionConcurrencyRequest(arg0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutFunctionConcurrencyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.PutFunctionConcurrencyOutput)
	return ret0, ret1
}

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

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

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

// PutFunctionEventInvokeConfig mocks base method
func (m *MockLambdaAPI) PutFunctionEventInvokeConfig(arg0 *lambda.PutFunctionEventInvokeConfigInput) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutFunctionEventInvokeConfig", arg0)
	ret0, _ := ret[0].(*lambda.PutFunctionEventInvokeConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutFunctionEventInvokeConfigRequest mocks base method
func (m *MockLambdaAPI) PutFunctionEventInvokeConfigRequest(arg0 *lambda.PutFunctionEventInvokeConfigInput) (*request.Request, *lambda.PutFunctionEventInvokeConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutFunctionEventInvokeConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.PutFunctionEventInvokeConfigOutput)
	return ret0, ret1
}

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

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

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

// PutProvisionedConcurrencyConfig mocks base method
func (m *MockLambdaAPI) PutProvisionedConcurrencyConfig(arg0 *lambda.PutProvisionedConcurrencyConfigInput) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutProvisionedConcurrencyConfig", arg0)
	ret0, _ := ret[0].(*lambda.PutProvisionedConcurrencyConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutProvisionedConcurrencyConfigRequest mocks base method
func (m *MockLambdaAPI) PutProvisionedConcurrencyConfigRequest(arg0 *lambda.PutProvisionedConcurrencyConfigInput) (*request.Request, *lambda.PutProvisionedConcurrencyConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutProvisionedConcurrencyConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.PutProvisionedConcurrencyConfigOutput)
	return ret0, ret1
}

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

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

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

// RemoveLayerVersionPermission mocks base method
func (m *MockLambdaAPI) RemoveLayerVersionPermission(arg0 *lambda.RemoveLayerVersionPermissionInput) (*lambda.RemoveLayerVersionPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveLayerVersionPermission", arg0)
	ret0, _ := ret[0].(*lambda.RemoveLayerVersionPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveLayerVersionPermissionRequest mocks base method
func (m *MockLambdaAPI) RemoveLayerVersionPermissionRequest(arg0 *lambda.RemoveLayerVersionPermissionInput) (*request.Request, *lambda.RemoveLayerVersionPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveLayerVersionPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.RemoveLayerVersionPermissionOutput)
	return ret0, ret1
}

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

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

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

// RemovePermission mocks base method
func (m *MockLambdaAPI) RemovePermission(arg0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePermission", arg0)
	ret0, _ := ret[0].(*lambda.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemovePermissionRequest mocks base method
func (m *MockLambdaAPI) RemovePermissionRequest(arg0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.RemovePermissionOutput)
	return ret0, ret1
}

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

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

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

// TagResource mocks base method
func (m *MockLambdaAPI) TagResource(arg0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResource", arg0)
	ret0, _ := ret[0].(*lambda.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResourceRequest mocks base method
func (m *MockLambdaAPI) TagResourceRequest(arg0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.TagResourceOutput)
	return ret0, ret1
}

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

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

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

// UntagResource mocks base method
func (m *MockLambdaAPI) UntagResource(arg0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResource", arg0)
	ret0, _ := ret[0].(*lambda.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResourceRequest mocks base method
func (m *MockLambdaAPI) UntagResourceRequest(arg0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.UntagResourceOutput)
	return ret0, ret1
}

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

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

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

// UpdateAlias mocks base method
func (m *MockLambdaAPI) UpdateAlias(arg0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAlias", arg0)
	ret0, _ := ret[0].(*lambda.AliasConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAliasRequest mocks base method
func (m *MockLambdaAPI) UpdateAliasRequest(arg0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.AliasConfiguration)
	return ret0, ret1
}

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

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

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

// UpdateEventSourceMapping mocks base method
func (m *MockLambdaAPI) UpdateEventSourceMapping(arg0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEventSourceMapping", arg0)
	ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateEventSourceMappingRequest mocks base method
func (m *MockLambdaAPI) UpdateEventSourceMappingRequest(arg0 *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEventSourceMappingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
	return ret0, ret1
}

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

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

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

// UpdateFunctionCode mocks base method
func (m *MockLambdaAPI) UpdateFunctionCode(arg0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFunctionCode", arg0)
	ret0, _ := ret[0].(*lambda.FunctionConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFunctionCodeRequest mocks base method
func (m *MockLambdaAPI) UpdateFunctionCodeRequest(arg0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFunctionCodeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.FunctionConfiguration)
	return ret0, ret1
}

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

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

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

// UpdateFunctionConfiguration mocks base method
func (m *MockLambdaAPI) UpdateFunctionConfiguration(arg0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFunctionConfiguration", arg0)
	ret0, _ := ret[0].(*lambda.FunctionConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFunctionConfigurationRequest mocks base method
func (m *MockLambdaAPI) UpdateFunctionConfigurationRequest(arg0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFunctionConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.FunctionConfiguration)
	return ret0, ret1
}

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

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

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

// UpdateFunctionEventInvokeConfig mocks base method
func (m *MockLambdaAPI) UpdateFunctionEventInvokeConfig(arg0 *lambda.UpdateFunctionEventInvokeConfigInput) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFunctionEventInvokeConfig", arg0)
	ret0, _ := ret[0].(*lambda.UpdateFunctionEventInvokeConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFunctionEventInvokeConfigRequest mocks base method
func (m *MockLambdaAPI) UpdateFunctionEventInvokeConfigRequest(arg0 *lambda.UpdateFunctionEventInvokeConfigInput) (*request.Request, *lambda.UpdateFunctionEventInvokeConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFunctionEventInvokeConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*lambda.UpdateFunctionEventInvokeConfigOutput)
	return ret0, ret1
}

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

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

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

// WaitUntilFunctionActive mocks base method
func (m *MockLambdaAPI) WaitUntilFunctionActive(arg0 *lambda.GetFunctionConfigurationInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilFunctionActive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// WaitUntilFunctionExists mocks base method
func (m *MockLambdaAPI) WaitUntilFunctionExists(arg0 *lambda.GetFunctionInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilFunctionExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// WaitUntilFunctionUpdated mocks base method
func (m *MockLambdaAPI) WaitUntilFunctionUpdated(arg0 *lambda.GetFunctionConfigurationInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilFunctionUpdated", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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