//go:build unit || all
// +build unit all

package procedure

import (
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/service/lambda"
	"github.com/aws/aws-sdk-go/service/lambda/lambdaiface"
)

type mockLambda struct {
	invokeErr error
}

func (m *mockLambda) GetRuntimeManagementConfig(input *lambda.GetRuntimeManagementConfigInput) (*lambda.GetRuntimeManagementConfigOutput, error) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) GetRuntimeManagementConfigWithContext(context aws.Context, input *lambda.GetRuntimeManagementConfigInput, option ...request.Option) (*lambda.GetRuntimeManagementConfigOutput, error) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) GetRuntimeManagementConfigRequest(input *lambda.GetRuntimeManagementConfigInput) (*request.Request, *lambda.GetRuntimeManagementConfigOutput) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) InvokeWithResponseStream(input *lambda.InvokeWithResponseStreamInput) (*lambda.InvokeWithResponseStreamOutput, error) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) InvokeWithResponseStreamWithContext(context aws.Context, input *lambda.InvokeWithResponseStreamInput, option ...request.Option) (*lambda.InvokeWithResponseStreamOutput, error) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) InvokeWithResponseStreamRequest(input *lambda.InvokeWithResponseStreamInput) (*request.Request, *lambda.InvokeWithResponseStreamOutput) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) PutRuntimeManagementConfig(input *lambda.PutRuntimeManagementConfigInput) (*lambda.PutRuntimeManagementConfigOutput, error) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) PutRuntimeManagementConfigWithContext(context aws.Context, input *lambda.PutRuntimeManagementConfigInput, option ...request.Option) (*lambda.PutRuntimeManagementConfigOutput, error) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) PutRuntimeManagementConfigRequest(input *lambda.PutRuntimeManagementConfigInput) (*request.Request, *lambda.PutRuntimeManagementConfigOutput) {
	//TODO implement me
	panic("implement me")
}

func (m *mockLambda) AddLayerVersionPermission(_ *lambda.AddLayerVersionPermissionInput) (*lambda.AddLayerVersionPermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) AddLayerVersionPermissionWithContext(_ aws.Context, _ *lambda.AddLayerVersionPermissionInput, _ ...request.Option) (*lambda.AddLayerVersionPermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) AddLayerVersionPermissionRequest(_ *lambda.AddLayerVersionPermissionInput) (*request.Request, *lambda.AddLayerVersionPermissionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) AddPermission(_ *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) AddPermissionWithContext(_ aws.Context, _ *lambda.AddPermissionInput, _ ...request.Option) (*lambda.AddPermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) AddPermissionRequest(_ *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateAlias(_ *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateAliasWithContext(_ aws.Context, _ *lambda.CreateAliasInput, _ ...request.Option) (*lambda.AliasConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateAliasRequest(_ *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateCodeSigningConfig(_ *lambda.CreateCodeSigningConfigInput) (*lambda.CreateCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateCodeSigningConfigWithContext(_ aws.Context, _ *lambda.CreateCodeSigningConfigInput, _ ...request.Option) (*lambda.CreateCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateCodeSigningConfigRequest(_ *lambda.CreateCodeSigningConfigInput) (*request.Request, *lambda.CreateCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateEventSourceMapping(_ *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateEventSourceMappingWithContext(_ aws.Context, _ *lambda.CreateEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateEventSourceMappingRequest(_ *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateFunction(_ *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateFunctionWithContext(_ aws.Context, _ *lambda.CreateFunctionInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateFunctionRequest(_ *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) CreateFunctionUrlConfig(*lambda.CreateFunctionUrlConfigInput) (*lambda.CreateFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}
func (m *mockLambda) CreateFunctionUrlConfigWithContext(aws.Context, *lambda.CreateFunctionUrlConfigInput, ...request.Option) (*lambda.CreateFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}
func (m *mockLambda) CreateFunctionUrlConfigRequest(*lambda.CreateFunctionUrlConfigInput) (*request.Request, *lambda.CreateFunctionUrlConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteAlias(_ *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteAliasWithContext(_ aws.Context, _ *lambda.DeleteAliasInput, _ ...request.Option) (*lambda.DeleteAliasOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteAliasRequest(_ *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteCodeSigningConfig(_ *lambda.DeleteCodeSigningConfigInput) (*lambda.DeleteCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteCodeSigningConfigWithContext(_ aws.Context, _ *lambda.DeleteCodeSigningConfigInput, _ ...request.Option) (*lambda.DeleteCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteCodeSigningConfigRequest(_ *lambda.DeleteCodeSigningConfigInput) (*request.Request, *lambda.DeleteCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteEventSourceMapping(_ *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteEventSourceMappingWithContext(_ aws.Context, _ *lambda.DeleteEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteEventSourceMappingRequest(_ *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunction(_ *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionWithContext(_ aws.Context, _ *lambda.DeleteFunctionInput, _ ...request.Option) (*lambda.DeleteFunctionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionRequest(_ *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionCodeSigningConfig(_ *lambda.DeleteFunctionCodeSigningConfigInput) (*lambda.DeleteFunctionCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionCodeSigningConfigWithContext(_ aws.Context, _ *lambda.DeleteFunctionCodeSigningConfigInput, _ ...request.Option) (*lambda.DeleteFunctionCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionCodeSigningConfigRequest(_ *lambda.DeleteFunctionCodeSigningConfigInput) (*request.Request, *lambda.DeleteFunctionCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionConcurrency(_ *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionConcurrencyWithContext(_ aws.Context, _ *lambda.DeleteFunctionConcurrencyInput, _ ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionConcurrencyRequest(_ *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionEventInvokeConfig(_ *lambda.DeleteFunctionEventInvokeConfigInput) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionEventInvokeConfigWithContext(_ aws.Context, _ *lambda.DeleteFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionEventInvokeConfigRequest(_ *lambda.DeleteFunctionEventInvokeConfigInput) (*request.Request, *lambda.DeleteFunctionEventInvokeConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionUrlConfig(*lambda.DeleteFunctionUrlConfigInput) (*lambda.DeleteFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionUrlConfigWithContext(aws.Context, *lambda.DeleteFunctionUrlConfigInput, ...request.Option) (*lambda.DeleteFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteFunctionUrlConfigRequest(*lambda.DeleteFunctionUrlConfigInput) (*request.Request, *lambda.DeleteFunctionUrlConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteLayerVersion(_ *lambda.DeleteLayerVersionInput) (*lambda.DeleteLayerVersionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteLayerVersionWithContext(_ aws.Context, _ *lambda.DeleteLayerVersionInput, _ ...request.Option) (*lambda.DeleteLayerVersionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteLayerVersionRequest(_ *lambda.DeleteLayerVersionInput) (*request.Request, *lambda.DeleteLayerVersionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteProvisionedConcurrencyConfig(_ *lambda.DeleteProvisionedConcurrencyConfigInput) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteProvisionedConcurrencyConfigWithContext(_ aws.Context, _ *lambda.DeleteProvisionedConcurrencyConfigInput, _ ...request.Option) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) DeleteProvisionedConcurrencyConfigRequest(_ *lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetAccountSettings(_ *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetAccountSettingsWithContext(_ aws.Context, _ *lambda.GetAccountSettingsInput, _ ...request.Option) (*lambda.GetAccountSettingsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetAccountSettingsRequest(_ *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetAlias(_ *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetAliasWithContext(_ aws.Context, _ *lambda.GetAliasInput, _ ...request.Option) (*lambda.AliasConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetAliasRequest(_ *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetCodeSigningConfig(_ *lambda.GetCodeSigningConfigInput) (*lambda.GetCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetCodeSigningConfigWithContext(_ aws.Context, _ *lambda.GetCodeSigningConfigInput, _ ...request.Option) (*lambda.GetCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetCodeSigningConfigRequest(_ *lambda.GetCodeSigningConfigInput) (*request.Request, *lambda.GetCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetEventSourceMapping(_ *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetEventSourceMappingWithContext(_ aws.Context, _ *lambda.GetEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetEventSourceMappingRequest(_ *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunction(_ *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionWithContext(_ aws.Context, _ *lambda.GetFunctionInput, _ ...request.Option) (*lambda.GetFunctionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionRequest(_ *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionCodeSigningConfig(_ *lambda.GetFunctionCodeSigningConfigInput) (*lambda.GetFunctionCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionCodeSigningConfigWithContext(_ aws.Context, _ *lambda.GetFunctionCodeSigningConfigInput, _ ...request.Option) (*lambda.GetFunctionCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionCodeSigningConfigRequest(_ *lambda.GetFunctionCodeSigningConfigInput) (*request.Request, *lambda.GetFunctionCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionConcurrency(_ *lambda.GetFunctionConcurrencyInput) (*lambda.GetFunctionConcurrencyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionConcurrencyWithContext(_ aws.Context, _ *lambda.GetFunctionConcurrencyInput, _ ...request.Option) (*lambda.GetFunctionConcurrencyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionConcurrencyRequest(_ *lambda.GetFunctionConcurrencyInput) (*request.Request, *lambda.GetFunctionConcurrencyOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionConfiguration(_ *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionConfigurationWithContext(_ aws.Context, _ *lambda.GetFunctionConfigurationInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionConfigurationRequest(_ *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionEventInvokeConfig(_ *lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionEventInvokeConfigWithContext(_ aws.Context, _ *lambda.GetFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionEventInvokeConfigRequest(_ *lambda.GetFunctionEventInvokeConfigInput) (*request.Request, *lambda.GetFunctionEventInvokeConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionUrlConfig(*lambda.GetFunctionUrlConfigInput) (*lambda.GetFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionUrlConfigWithContext(aws.Context, *lambda.GetFunctionUrlConfigInput, ...request.Option) (*lambda.GetFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetFunctionUrlConfigRequest(*lambda.GetFunctionUrlConfigInput) (*request.Request, *lambda.GetFunctionUrlConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersion(_ *lambda.GetLayerVersionInput) (*lambda.GetLayerVersionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionWithContext(_ aws.Context, _ *lambda.GetLayerVersionInput, _ ...request.Option) (*lambda.GetLayerVersionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionRequest(_ *lambda.GetLayerVersionInput) (*request.Request, *lambda.GetLayerVersionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionByArn(_ *lambda.GetLayerVersionByArnInput) (*lambda.GetLayerVersionByArnOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionByArnWithContext(_ aws.Context, _ *lambda.GetLayerVersionByArnInput, _ ...request.Option) (*lambda.GetLayerVersionByArnOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionByArnRequest(_ *lambda.GetLayerVersionByArnInput) (*request.Request, *lambda.GetLayerVersionByArnOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionPolicy(_ *lambda.GetLayerVersionPolicyInput) (*lambda.GetLayerVersionPolicyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionPolicyWithContext(_ aws.Context, _ *lambda.GetLayerVersionPolicyInput, _ ...request.Option) (*lambda.GetLayerVersionPolicyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetLayerVersionPolicyRequest(_ *lambda.GetLayerVersionPolicyInput) (*request.Request, *lambda.GetLayerVersionPolicyOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetPolicy(_ *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetPolicyWithContext(_ aws.Context, _ *lambda.GetPolicyInput, _ ...request.Option) (*lambda.GetPolicyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetPolicyRequest(_ *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetProvisionedConcurrencyConfig(_ *lambda.GetProvisionedConcurrencyConfigInput) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetProvisionedConcurrencyConfigWithContext(_ aws.Context, _ *lambda.GetProvisionedConcurrencyConfigInput, _ ...request.Option) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) GetProvisionedConcurrencyConfigRequest(_ *lambda.GetProvisionedConcurrencyConfigInput) (*request.Request, *lambda.GetProvisionedConcurrencyConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) Invoke(_ *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) InvokeWithContext(_ aws.Context, _ *lambda.InvokeInput, _ ...request.Option) (*lambda.InvokeOutput, error) {
	return nil, m.invokeErr
}

func (m *mockLambda) InvokeRequest(_ *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) InvokeAsync(_ *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) InvokeAsyncWithContext(_ aws.Context, _ *lambda.InvokeAsyncInput, _ ...request.Option) (*lambda.InvokeAsyncOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) InvokeAsyncRequest(_ *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListAliases(_ *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListAliasesWithContext(_ aws.Context, _ *lambda.ListAliasesInput, _ ...request.Option) (*lambda.ListAliasesOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListAliasesRequest(_ *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListAliasesPages(_ *lambda.ListAliasesInput, _ func(*lambda.ListAliasesOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListAliasesPagesWithContext(_ aws.Context, _ *lambda.ListAliasesInput, _ func(*lambda.ListAliasesOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListCodeSigningConfigs(_ *lambda.ListCodeSigningConfigsInput) (*lambda.ListCodeSigningConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListCodeSigningConfigsWithContext(_ aws.Context, _ *lambda.ListCodeSigningConfigsInput, _ ...request.Option) (*lambda.ListCodeSigningConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListCodeSigningConfigsRequest(_ *lambda.ListCodeSigningConfigsInput) (*request.Request, *lambda.ListCodeSigningConfigsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListCodeSigningConfigsPages(_ *lambda.ListCodeSigningConfigsInput, _ func(*lambda.ListCodeSigningConfigsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListCodeSigningConfigsPagesWithContext(_ aws.Context, _ *lambda.ListCodeSigningConfigsInput, _ func(*lambda.ListCodeSigningConfigsOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListEventSourceMappings(_ *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListEventSourceMappingsWithContext(_ aws.Context, _ *lambda.ListEventSourceMappingsInput, _ ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListEventSourceMappingsRequest(_ *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListEventSourceMappingsPages(_ *lambda.ListEventSourceMappingsInput, _ func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListEventSourceMappingsPagesWithContext(_ aws.Context, _ *lambda.ListEventSourceMappingsInput, _ func(*lambda.ListEventSourceMappingsOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionEventInvokeConfigs(_ *lambda.ListFunctionEventInvokeConfigsInput) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionEventInvokeConfigsWithContext(_ aws.Context, _ *lambda.ListFunctionEventInvokeConfigsInput, _ ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionEventInvokeConfigsRequest(_ *lambda.ListFunctionEventInvokeConfigsInput) (*request.Request, *lambda.ListFunctionEventInvokeConfigsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionEventInvokeConfigsPages(_ *lambda.ListFunctionEventInvokeConfigsInput, _ func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionEventInvokeConfigsPagesWithContext(_ aws.Context, _ *lambda.ListFunctionEventInvokeConfigsInput, _ func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionUrlConfigs(*lambda.ListFunctionUrlConfigsInput) (*lambda.ListFunctionUrlConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionUrlConfigsWithContext(aws.Context, *lambda.ListFunctionUrlConfigsInput, ...request.Option) (*lambda.ListFunctionUrlConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionUrlConfigsRequest(*lambda.ListFunctionUrlConfigsInput) (*request.Request, *lambda.ListFunctionUrlConfigsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionUrlConfigsPages(*lambda.ListFunctionUrlConfigsInput, func(*lambda.ListFunctionUrlConfigsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionUrlConfigsPagesWithContext(aws.Context, *lambda.ListFunctionUrlConfigsInput, func(*lambda.ListFunctionUrlConfigsOutput, bool) bool, ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctions(_ *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsWithContext(_ aws.Context, _ *lambda.ListFunctionsInput, _ ...request.Option) (*lambda.ListFunctionsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsRequest(_ *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsPages(_ *lambda.ListFunctionsInput, _ func(*lambda.ListFunctionsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsPagesWithContext(_ aws.Context, _ *lambda.ListFunctionsInput, _ func(*lambda.ListFunctionsOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsByCodeSigningConfig(_ *lambda.ListFunctionsByCodeSigningConfigInput) (*lambda.ListFunctionsByCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsByCodeSigningConfigWithContext(_ aws.Context, _ *lambda.ListFunctionsByCodeSigningConfigInput, _ ...request.Option) (*lambda.ListFunctionsByCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsByCodeSigningConfigRequest(_ *lambda.ListFunctionsByCodeSigningConfigInput) (*request.Request, *lambda.ListFunctionsByCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsByCodeSigningConfigPages(_ *lambda.ListFunctionsByCodeSigningConfigInput, _ func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListFunctionsByCodeSigningConfigPagesWithContext(_ aws.Context, _ *lambda.ListFunctionsByCodeSigningConfigInput, _ func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayerVersions(_ *lambda.ListLayerVersionsInput) (*lambda.ListLayerVersionsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayerVersionsWithContext(_ aws.Context, _ *lambda.ListLayerVersionsInput, _ ...request.Option) (*lambda.ListLayerVersionsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayerVersionsRequest(_ *lambda.ListLayerVersionsInput) (*request.Request, *lambda.ListLayerVersionsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayerVersionsPages(_ *lambda.ListLayerVersionsInput, _ func(*lambda.ListLayerVersionsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayerVersionsPagesWithContext(_ aws.Context, _ *lambda.ListLayerVersionsInput, _ func(*lambda.ListLayerVersionsOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayers(_ *lambda.ListLayersInput) (*lambda.ListLayersOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayersWithContext(_ aws.Context, _ *lambda.ListLayersInput, _ ...request.Option) (*lambda.ListLayersOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayersRequest(_ *lambda.ListLayersInput) (*request.Request, *lambda.ListLayersOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayersPages(_ *lambda.ListLayersInput, _ func(*lambda.ListLayersOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListLayersPagesWithContext(_ aws.Context, _ *lambda.ListLayersInput, _ func(*lambda.ListLayersOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListProvisionedConcurrencyConfigs(_ *lambda.ListProvisionedConcurrencyConfigsInput) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListProvisionedConcurrencyConfigsWithContext(_ aws.Context, _ *lambda.ListProvisionedConcurrencyConfigsInput, _ ...request.Option) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListProvisionedConcurrencyConfigsRequest(_ *lambda.ListProvisionedConcurrencyConfigsInput) (*request.Request, *lambda.ListProvisionedConcurrencyConfigsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListProvisionedConcurrencyConfigsPages(_ *lambda.ListProvisionedConcurrencyConfigsInput, _ func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListProvisionedConcurrencyConfigsPagesWithContext(_ aws.Context, _ *lambda.ListProvisionedConcurrencyConfigsInput, _ func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListTags(_ *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListTagsWithContext(_ aws.Context, _ *lambda.ListTagsInput, _ ...request.Option) (*lambda.ListTagsOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListTagsRequest(_ *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListVersionsByFunction(_ *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListVersionsByFunctionWithContext(_ aws.Context, _ *lambda.ListVersionsByFunctionInput, _ ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListVersionsByFunctionRequest(_ *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListVersionsByFunctionPages(_ *lambda.ListVersionsByFunctionInput, _ func(*lambda.ListVersionsByFunctionOutput, bool) bool) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) ListVersionsByFunctionPagesWithContext(_ aws.Context, _ *lambda.ListVersionsByFunctionInput, _ func(*lambda.ListVersionsByFunctionOutput, bool) bool, _ ...request.Option) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PublishLayerVersion(_ *lambda.PublishLayerVersionInput) (*lambda.PublishLayerVersionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PublishLayerVersionWithContext(_ aws.Context, _ *lambda.PublishLayerVersionInput, _ ...request.Option) (*lambda.PublishLayerVersionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PublishLayerVersionRequest(_ *lambda.PublishLayerVersionInput) (*request.Request, *lambda.PublishLayerVersionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PublishVersion(_ *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PublishVersionWithContext(_ aws.Context, _ *lambda.PublishVersionInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PublishVersionRequest(_ *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionCodeSigningConfig(_ *lambda.PutFunctionCodeSigningConfigInput) (*lambda.PutFunctionCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionCodeSigningConfigWithContext(_ aws.Context, _ *lambda.PutFunctionCodeSigningConfigInput, _ ...request.Option) (*lambda.PutFunctionCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionCodeSigningConfigRequest(_ *lambda.PutFunctionCodeSigningConfigInput) (*request.Request, *lambda.PutFunctionCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionConcurrency(_ *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionConcurrencyWithContext(_ aws.Context, _ *lambda.PutFunctionConcurrencyInput, _ ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionConcurrencyRequest(_ *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionEventInvokeConfig(_ *lambda.PutFunctionEventInvokeConfigInput) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionEventInvokeConfigWithContext(_ aws.Context, _ *lambda.PutFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutFunctionEventInvokeConfigRequest(_ *lambda.PutFunctionEventInvokeConfigInput) (*request.Request, *lambda.PutFunctionEventInvokeConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutProvisionedConcurrencyConfig(_ *lambda.PutProvisionedConcurrencyConfigInput) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutProvisionedConcurrencyConfigWithContext(_ aws.Context, _ *lambda.PutProvisionedConcurrencyConfigInput, _ ...request.Option) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) PutProvisionedConcurrencyConfigRequest(_ *lambda.PutProvisionedConcurrencyConfigInput) (*request.Request, *lambda.PutProvisionedConcurrencyConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) RemoveLayerVersionPermission(_ *lambda.RemoveLayerVersionPermissionInput) (*lambda.RemoveLayerVersionPermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) RemoveLayerVersionPermissionWithContext(_ aws.Context, _ *lambda.RemoveLayerVersionPermissionInput, _ ...request.Option) (*lambda.RemoveLayerVersionPermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) RemoveLayerVersionPermissionRequest(_ *lambda.RemoveLayerVersionPermissionInput) (*request.Request, *lambda.RemoveLayerVersionPermissionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) RemovePermission(_ *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) RemovePermissionWithContext(_ aws.Context, _ *lambda.RemovePermissionInput, _ ...request.Option) (*lambda.RemovePermissionOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) RemovePermissionRequest(_ *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) TagResource(_ *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) TagResourceWithContext(_ aws.Context, _ *lambda.TagResourceInput, _ ...request.Option) (*lambda.TagResourceOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) TagResourceRequest(_ *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UntagResource(_ *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UntagResourceWithContext(_ aws.Context, _ *lambda.UntagResourceInput, _ ...request.Option) (*lambda.UntagResourceOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UntagResourceRequest(_ *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateAlias(_ *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateAliasWithContext(_ aws.Context, _ *lambda.UpdateAliasInput, _ ...request.Option) (*lambda.AliasConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateAliasRequest(_ *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateCodeSigningConfig(_ *lambda.UpdateCodeSigningConfigInput) (*lambda.UpdateCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateCodeSigningConfigWithContext(_ aws.Context, _ *lambda.UpdateCodeSigningConfigInput, _ ...request.Option) (*lambda.UpdateCodeSigningConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateCodeSigningConfigRequest(_ *lambda.UpdateCodeSigningConfigInput) (*request.Request, *lambda.UpdateCodeSigningConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateEventSourceMapping(_ *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateEventSourceMappingWithContext(_ aws.Context, _ *lambda.UpdateEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateEventSourceMappingRequest(_ *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionCode(_ *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionCodeWithContext(_ aws.Context, _ *lambda.UpdateFunctionCodeInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionCodeRequest(_ *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionConfiguration(_ *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionConfigurationWithContext(_ aws.Context, _ *lambda.UpdateFunctionConfigurationInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionConfigurationRequest(_ *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionEventInvokeConfig(_ *lambda.UpdateFunctionEventInvokeConfigInput) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionEventInvokeConfigWithContext(_ aws.Context, _ *lambda.UpdateFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionEventInvokeConfigRequest(_ *lambda.UpdateFunctionEventInvokeConfigInput) (*request.Request, *lambda.UpdateFunctionEventInvokeConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionUrlConfig(*lambda.UpdateFunctionUrlConfigInput) (*lambda.UpdateFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionUrlConfigWithContext(aws.Context, *lambda.UpdateFunctionUrlConfigInput, ...request.Option) (*lambda.UpdateFunctionUrlConfigOutput, error) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) UpdateFunctionUrlConfigRequest(*lambda.UpdateFunctionUrlConfigInput) (*request.Request, *lambda.UpdateFunctionUrlConfigOutput) {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionActive(_ *lambda.GetFunctionConfigurationInput) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionActiveWithContext(_ aws.Context, _ *lambda.GetFunctionConfigurationInput, _ ...request.WaiterOption) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionExists(_ *lambda.GetFunctionInput) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionExistsWithContext(_ aws.Context, _ *lambda.GetFunctionInput, _ ...request.WaiterOption) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionUpdated(_ *lambda.GetFunctionConfigurationInput) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionUpdatedWithContext(_ aws.Context, _ *lambda.GetFunctionConfigurationInput, _ ...request.WaiterOption) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionActiveV2(*lambda.GetFunctionInput) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionActiveV2WithContext(aws.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionUpdatedV2(*lambda.GetFunctionInput) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilFunctionUpdatedV2WithContext(aws.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilPublishedVersionActive(_ *lambda.GetFunctionConfigurationInput) error {
	panic("not implemented") // TODO: Implement
}

func (m *mockLambda) WaitUntilPublishedVersionActiveWithContext(aws.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error {
	panic("not implemented") // TODO: Implement
}

func fakeLambdaAPI(invokeErr error) lambdaiface.LambdaAPI {
	return &mockLambda{
		invokeErr: invokeErr,
	}
}