double.go

// Code generated by go doublegen; DO NOT EDIT.
// This file was generated at 2020-02-14T22:13:36+11:00

// Package lambdadouble provides a TestDouble implementation of lambdaiface.LambdaAPI
package lambdadouble

import (
	"context"

	"github.com/aws/aws-sdk-go/aws/awserr"
	"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"
	"github.com/lwoggardner/awsdouble"
	"github.com/lwoggardner/godouble/godouble"
)

// LambdaDouble is TestDouble for lambdaiface.LambdaAPI
type LambdaDouble struct {
	lambdaiface.LambdaAPI
	*awsdouble.AWSTestDouble
}

// Constructor for LambdaDouble
// Default configuration will ensure
//   * API operations not explicitly stubbed will return an empty output struct pointer, and nil error.
//     To simulate long polling, "Poll" operations will return these values after a random delay of up to 100ms.
//   * WithContext methods implement a 'Fake' method that returns a cancellation error if the context is cancelled
//      before the method is called.
//   * Pages and PagesWithContext methods similarly implement a 'Fake' method that paginates over the underlying method.
//
//    This allows tests to only stub the simple api methods and be generally unconcerned whether the SUT is using the
//      Context or Pagination forms of the API.
//
func NewDouble(t godouble.T, configurators ...func(*awsdouble.AWSTestDouble)) *LambdaDouble {
	result := &LambdaDouble{}

	configurators = append([]func(configurator *awsdouble.AWSTestDouble){func(d *awsdouble.AWSTestDouble) {
		d.SetDefaultCall(result.defaultMethodCall)
		d.SetDefaultReturnValues(result.defaultReturnValues)
	}}, configurators...)

	result.AWSTestDouble = awsdouble.NewDouble(t, (*lambdaiface.LambdaAPI)(nil), configurators...)
	return result
}

func (d *LambdaDouble) defaultReturnValues(m godouble.Method) godouble.ReturnValues {
	return d.DefaultReturnValues(m)
}

func (d *LambdaDouble) defaultMethodCall(m godouble.Method) godouble.MethodCall {
	switch m.Reflect().Name {

	case "AddLayerVersionPermissionWithContext":
		return m.Fake(d.fakeAddLayerVersionPermissionWithContext)

	case "AddPermissionWithContext":
		return m.Fake(d.fakeAddPermissionWithContext)

	case "CreateAliasWithContext":
		return m.Fake(d.fakeCreateAliasWithContext)

	case "CreateEventSourceMappingWithContext":
		return m.Fake(d.fakeCreateEventSourceMappingWithContext)

	case "CreateFunctionWithContext":
		return m.Fake(d.fakeCreateFunctionWithContext)

	case "DeleteAliasWithContext":
		return m.Fake(d.fakeDeleteAliasWithContext)

	case "DeleteEventSourceMappingWithContext":
		return m.Fake(d.fakeDeleteEventSourceMappingWithContext)

	case "DeleteFunctionConcurrencyWithContext":
		return m.Fake(d.fakeDeleteFunctionConcurrencyWithContext)

	case "DeleteFunctionEventInvokeConfigWithContext":
		return m.Fake(d.fakeDeleteFunctionEventInvokeConfigWithContext)

	case "DeleteFunctionWithContext":
		return m.Fake(d.fakeDeleteFunctionWithContext)

	case "DeleteLayerVersionWithContext":
		return m.Fake(d.fakeDeleteLayerVersionWithContext)

	case "DeleteProvisionedConcurrencyConfigWithContext":
		return m.Fake(d.fakeDeleteProvisionedConcurrencyConfigWithContext)

	case "GetAccountSettingsWithContext":
		return m.Fake(d.fakeGetAccountSettingsWithContext)

	case "GetAliasWithContext":
		return m.Fake(d.fakeGetAliasWithContext)

	case "GetEventSourceMappingWithContext":
		return m.Fake(d.fakeGetEventSourceMappingWithContext)

	case "GetFunctionConcurrencyWithContext":
		return m.Fake(d.fakeGetFunctionConcurrencyWithContext)

	case "GetFunctionConfigurationWithContext":
		return m.Fake(d.fakeGetFunctionConfigurationWithContext)

	case "GetFunctionEventInvokeConfigWithContext":
		return m.Fake(d.fakeGetFunctionEventInvokeConfigWithContext)

	case "GetFunctionWithContext":
		return m.Fake(d.fakeGetFunctionWithContext)

	case "GetLayerVersionByArnWithContext":
		return m.Fake(d.fakeGetLayerVersionByArnWithContext)

	case "GetLayerVersionPolicyWithContext":
		return m.Fake(d.fakeGetLayerVersionPolicyWithContext)

	case "GetLayerVersionWithContext":
		return m.Fake(d.fakeGetLayerVersionWithContext)

	case "GetPolicyWithContext":
		return m.Fake(d.fakeGetPolicyWithContext)

	case "GetProvisionedConcurrencyConfigWithContext":
		return m.Fake(d.fakeGetProvisionedConcurrencyConfigWithContext)

	case "InvokeAsyncWithContext":
		return m.Fake(d.fakeInvokeAsyncWithContext)

	case "InvokeWithContext":
		return m.Fake(d.fakeInvokeWithContext)

	case "ListAliasesPages":
		return m.Fake(d.fakeListAliasesPages)

	case "ListAliasesPagesWithContext":
		return m.Fake(d.fakeListAliasesPagesWithContext)

	case "ListAliasesWithContext":
		return m.Fake(d.fakeListAliasesWithContext)

	case "ListEventSourceMappingsPages":
		return m.Fake(d.fakeListEventSourceMappingsPages)

	case "ListEventSourceMappingsPagesWithContext":
		return m.Fake(d.fakeListEventSourceMappingsPagesWithContext)

	case "ListEventSourceMappingsWithContext":
		return m.Fake(d.fakeListEventSourceMappingsWithContext)

	case "ListFunctionEventInvokeConfigsPages":
		return m.Fake(d.fakeListFunctionEventInvokeConfigsPages)

	case "ListFunctionEventInvokeConfigsPagesWithContext":
		return m.Fake(d.fakeListFunctionEventInvokeConfigsPagesWithContext)

	case "ListFunctionEventInvokeConfigsWithContext":
		return m.Fake(d.fakeListFunctionEventInvokeConfigsWithContext)

	case "ListFunctionsPages":
		return m.Fake(d.fakeListFunctionsPages)

	case "ListFunctionsPagesWithContext":
		return m.Fake(d.fakeListFunctionsPagesWithContext)

	case "ListFunctionsWithContext":
		return m.Fake(d.fakeListFunctionsWithContext)

	case "ListLayerVersionsPages":
		return m.Fake(d.fakeListLayerVersionsPages)

	case "ListLayerVersionsPagesWithContext":
		return m.Fake(d.fakeListLayerVersionsPagesWithContext)

	case "ListLayerVersionsWithContext":
		return m.Fake(d.fakeListLayerVersionsWithContext)

	case "ListLayersPages":
		return m.Fake(d.fakeListLayersPages)

	case "ListLayersPagesWithContext":
		return m.Fake(d.fakeListLayersPagesWithContext)

	case "ListLayersWithContext":
		return m.Fake(d.fakeListLayersWithContext)

	case "ListProvisionedConcurrencyConfigsPages":
		return m.Fake(d.fakeListProvisionedConcurrencyConfigsPages)

	case "ListProvisionedConcurrencyConfigsPagesWithContext":
		return m.Fake(d.fakeListProvisionedConcurrencyConfigsPagesWithContext)

	case "ListProvisionedConcurrencyConfigsWithContext":
		return m.Fake(d.fakeListProvisionedConcurrencyConfigsWithContext)

	case "ListTagsWithContext":
		return m.Fake(d.fakeListTagsWithContext)

	case "ListVersionsByFunctionPages":
		return m.Fake(d.fakeListVersionsByFunctionPages)

	case "ListVersionsByFunctionPagesWithContext":
		return m.Fake(d.fakeListVersionsByFunctionPagesWithContext)

	case "ListVersionsByFunctionWithContext":
		return m.Fake(d.fakeListVersionsByFunctionWithContext)

	case "PublishLayerVersionWithContext":
		return m.Fake(d.fakePublishLayerVersionWithContext)

	case "PublishVersionWithContext":
		return m.Fake(d.fakePublishVersionWithContext)

	case "PutFunctionConcurrencyWithContext":
		return m.Fake(d.fakePutFunctionConcurrencyWithContext)

	case "PutFunctionEventInvokeConfigWithContext":
		return m.Fake(d.fakePutFunctionEventInvokeConfigWithContext)

	case "PutProvisionedConcurrencyConfigWithContext":
		return m.Fake(d.fakePutProvisionedConcurrencyConfigWithContext)

	case "RemoveLayerVersionPermissionWithContext":
		return m.Fake(d.fakeRemoveLayerVersionPermissionWithContext)

	case "RemovePermissionWithContext":
		return m.Fake(d.fakeRemovePermissionWithContext)

	case "TagResourceWithContext":
		return m.Fake(d.fakeTagResourceWithContext)

	case "UntagResourceWithContext":
		return m.Fake(d.fakeUntagResourceWithContext)

	case "UpdateAliasWithContext":
		return m.Fake(d.fakeUpdateAliasWithContext)

	case "UpdateEventSourceMappingWithContext":
		return m.Fake(d.fakeUpdateEventSourceMappingWithContext)

	case "UpdateFunctionCodeWithContext":
		return m.Fake(d.fakeUpdateFunctionCodeWithContext)

	case "UpdateFunctionConfigurationWithContext":
		return m.Fake(d.fakeUpdateFunctionConfigurationWithContext)

	case "UpdateFunctionEventInvokeConfigWithContext":
		return m.Fake(d.fakeUpdateFunctionEventInvokeConfigWithContext)

	case "WaitUntilFunctionActive":
		return m.Fake(d.fakeWaitUntilFunctionActive)

	case "WaitUntilFunctionActiveWithContext":
		return m.Fake(d.fakeWaitUntilFunctionActiveWithContext)

	case "WaitUntilFunctionExists":
		return m.Fake(d.fakeWaitUntilFunctionExists)

	case "WaitUntilFunctionExistsWithContext":
		return m.Fake(d.fakeWaitUntilFunctionExistsWithContext)

	case "WaitUntilFunctionUpdated":
		return m.Fake(d.fakeWaitUntilFunctionUpdated)

	case "WaitUntilFunctionUpdatedWithContext":
		return m.Fake(d.fakeWaitUntilFunctionUpdatedWithContext)

	default:
		return nil
	}
}

func (d *LambdaDouble) AddLayerVersionPermission(i0 *lambda.AddLayerVersionPermissionInput) (r0 *lambda.AddLayerVersionPermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AddLayerVersionPermission", i0)
	r0, _ = returns[0].(*lambda.AddLayerVersionPermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) AddLayerVersionPermissionRequest(i0 *lambda.AddLayerVersionPermissionInput) (r0 *request.Request, r1 *lambda.AddLayerVersionPermissionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AddLayerVersionPermissionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.AddLayerVersionPermissionOutput)
	return
}

func (d *LambdaDouble) AddLayerVersionPermissionWithContext(i0 context.Context, i1 *lambda.AddLayerVersionPermissionInput, i2 ...request.Option) (r0 *lambda.AddLayerVersionPermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AddLayerVersionPermissionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.AddLayerVersionPermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeAddLayerVersionPermissionWithContext(ctx context.Context, in *lambda.AddLayerVersionPermissionInput, _ ...request.Option) (*lambda.AddLayerVersionPermissionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "AddLayerVersionPermission cancelled", ctx.Err())
	default:
		return d.AddLayerVersionPermission(in)
	}
}

func (d *LambdaDouble) AddPermission(i0 *lambda.AddPermissionInput) (r0 *lambda.AddPermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AddPermission", i0)
	r0, _ = returns[0].(*lambda.AddPermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) AddPermissionRequest(i0 *lambda.AddPermissionInput) (r0 *request.Request, r1 *lambda.AddPermissionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AddPermissionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.AddPermissionOutput)
	return
}

func (d *LambdaDouble) AddPermissionWithContext(i0 context.Context, i1 *lambda.AddPermissionInput, i2 ...request.Option) (r0 *lambda.AddPermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AddPermissionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.AddPermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeAddPermissionWithContext(ctx context.Context, in *lambda.AddPermissionInput, _ ...request.Option) (*lambda.AddPermissionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "AddPermission cancelled", ctx.Err())
	default:
		return d.AddPermission(in)
	}
}

func (d *LambdaDouble) CreateAlias(i0 *lambda.CreateAliasInput) (r0 *lambda.AliasConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateAlias", i0)
	r0, _ = returns[0].(*lambda.AliasConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) CreateAliasRequest(i0 *lambda.CreateAliasInput) (r0 *request.Request, r1 *lambda.AliasConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateAliasRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.AliasConfiguration)
	return
}

func (d *LambdaDouble) CreateAliasWithContext(i0 context.Context, i1 *lambda.CreateAliasInput, i2 ...request.Option) (r0 *lambda.AliasConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateAliasWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.AliasConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeCreateAliasWithContext(ctx context.Context, in *lambda.CreateAliasInput, _ ...request.Option) (*lambda.AliasConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateAlias cancelled", ctx.Err())
	default:
		return d.CreateAlias(in)
	}
}

func (d *LambdaDouble) CreateEventSourceMapping(i0 *lambda.CreateEventSourceMappingInput) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateEventSourceMapping", i0)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) CreateEventSourceMappingRequest(i0 *lambda.CreateEventSourceMappingInput) (r0 *request.Request, r1 *lambda.EventSourceMappingConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateEventSourceMappingRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.EventSourceMappingConfiguration)
	return
}

func (d *LambdaDouble) CreateEventSourceMappingWithContext(i0 context.Context, i1 *lambda.CreateEventSourceMappingInput, i2 ...request.Option) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateEventSourceMappingWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeCreateEventSourceMappingWithContext(ctx context.Context, in *lambda.CreateEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateEventSourceMapping cancelled", ctx.Err())
	default:
		return d.CreateEventSourceMapping(in)
	}
}

func (d *LambdaDouble) CreateFunction(i0 *lambda.CreateFunctionInput) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateFunction", i0)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) CreateFunctionRequest(i0 *lambda.CreateFunctionInput) (r0 *request.Request, r1 *lambda.FunctionConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateFunctionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.FunctionConfiguration)
	return
}

func (d *LambdaDouble) CreateFunctionWithContext(i0 context.Context, i1 *lambda.CreateFunctionInput, i2 ...request.Option) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateFunctionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeCreateFunctionWithContext(ctx context.Context, in *lambda.CreateFunctionInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateFunction cancelled", ctx.Err())
	default:
		return d.CreateFunction(in)
	}
}

func (d *LambdaDouble) DeleteAlias(i0 *lambda.DeleteAliasInput) (r0 *lambda.DeleteAliasOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAlias", i0)
	r0, _ = returns[0].(*lambda.DeleteAliasOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteAliasRequest(i0 *lambda.DeleteAliasInput) (r0 *request.Request, r1 *lambda.DeleteAliasOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAliasRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.DeleteAliasOutput)
	return
}

func (d *LambdaDouble) DeleteAliasWithContext(i0 context.Context, i1 *lambda.DeleteAliasInput, i2 ...request.Option) (r0 *lambda.DeleteAliasOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAliasWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.DeleteAliasOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteAliasWithContext(ctx context.Context, in *lambda.DeleteAliasInput, _ ...request.Option) (*lambda.DeleteAliasOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteAlias cancelled", ctx.Err())
	default:
		return d.DeleteAlias(in)
	}
}

func (d *LambdaDouble) DeleteEventSourceMapping(i0 *lambda.DeleteEventSourceMappingInput) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteEventSourceMapping", i0)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteEventSourceMappingRequest(i0 *lambda.DeleteEventSourceMappingInput) (r0 *request.Request, r1 *lambda.EventSourceMappingConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteEventSourceMappingRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.EventSourceMappingConfiguration)
	return
}

func (d *LambdaDouble) DeleteEventSourceMappingWithContext(i0 context.Context, i1 *lambda.DeleteEventSourceMappingInput, i2 ...request.Option) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteEventSourceMappingWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteEventSourceMappingWithContext(ctx context.Context, in *lambda.DeleteEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteEventSourceMapping cancelled", ctx.Err())
	default:
		return d.DeleteEventSourceMapping(in)
	}
}

func (d *LambdaDouble) DeleteFunction(i0 *lambda.DeleteFunctionInput) (r0 *lambda.DeleteFunctionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunction", i0)
	r0, _ = returns[0].(*lambda.DeleteFunctionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteFunctionConcurrency(i0 *lambda.DeleteFunctionConcurrencyInput) (r0 *lambda.DeleteFunctionConcurrencyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionConcurrency", i0)
	r0, _ = returns[0].(*lambda.DeleteFunctionConcurrencyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteFunctionConcurrencyRequest(i0 *lambda.DeleteFunctionConcurrencyInput) (r0 *request.Request, r1 *lambda.DeleteFunctionConcurrencyOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionConcurrencyRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.DeleteFunctionConcurrencyOutput)
	return
}

func (d *LambdaDouble) DeleteFunctionConcurrencyWithContext(i0 context.Context, i1 *lambda.DeleteFunctionConcurrencyInput, i2 ...request.Option) (r0 *lambda.DeleteFunctionConcurrencyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionConcurrencyWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.DeleteFunctionConcurrencyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteFunctionConcurrencyWithContext(ctx context.Context, in *lambda.DeleteFunctionConcurrencyInput, _ ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteFunctionConcurrency cancelled", ctx.Err())
	default:
		return d.DeleteFunctionConcurrency(in)
	}
}

func (d *LambdaDouble) DeleteFunctionEventInvokeConfig(i0 *lambda.DeleteFunctionEventInvokeConfigInput) (r0 *lambda.DeleteFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionEventInvokeConfig", i0)
	r0, _ = returns[0].(*lambda.DeleteFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteFunctionEventInvokeConfigRequest(i0 *lambda.DeleteFunctionEventInvokeConfigInput) (r0 *request.Request, r1 *lambda.DeleteFunctionEventInvokeConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionEventInvokeConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.DeleteFunctionEventInvokeConfigOutput)
	return
}

func (d *LambdaDouble) DeleteFunctionEventInvokeConfigWithContext(i0 context.Context, i1 *lambda.DeleteFunctionEventInvokeConfigInput, i2 ...request.Option) (r0 *lambda.DeleteFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionEventInvokeConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.DeleteFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteFunctionEventInvokeConfigWithContext(ctx context.Context, in *lambda.DeleteFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteFunctionEventInvokeConfig cancelled", ctx.Err())
	default:
		return d.DeleteFunctionEventInvokeConfig(in)
	}
}

func (d *LambdaDouble) DeleteFunctionRequest(i0 *lambda.DeleteFunctionInput) (r0 *request.Request, r1 *lambda.DeleteFunctionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.DeleteFunctionOutput)
	return
}

func (d *LambdaDouble) DeleteFunctionWithContext(i0 context.Context, i1 *lambda.DeleteFunctionInput, i2 ...request.Option) (r0 *lambda.DeleteFunctionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteFunctionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.DeleteFunctionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteFunctionWithContext(ctx context.Context, in *lambda.DeleteFunctionInput, _ ...request.Option) (*lambda.DeleteFunctionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteFunction cancelled", ctx.Err())
	default:
		return d.DeleteFunction(in)
	}
}

func (d *LambdaDouble) DeleteLayerVersion(i0 *lambda.DeleteLayerVersionInput) (r0 *lambda.DeleteLayerVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteLayerVersion", i0)
	r0, _ = returns[0].(*lambda.DeleteLayerVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteLayerVersionRequest(i0 *lambda.DeleteLayerVersionInput) (r0 *request.Request, r1 *lambda.DeleteLayerVersionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteLayerVersionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.DeleteLayerVersionOutput)
	return
}

func (d *LambdaDouble) DeleteLayerVersionWithContext(i0 context.Context, i1 *lambda.DeleteLayerVersionInput, i2 ...request.Option) (r0 *lambda.DeleteLayerVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteLayerVersionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.DeleteLayerVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteLayerVersionWithContext(ctx context.Context, in *lambda.DeleteLayerVersionInput, _ ...request.Option) (*lambda.DeleteLayerVersionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteLayerVersion cancelled", ctx.Err())
	default:
		return d.DeleteLayerVersion(in)
	}
}

func (d *LambdaDouble) DeleteProvisionedConcurrencyConfig(i0 *lambda.DeleteProvisionedConcurrencyConfigInput) (r0 *lambda.DeleteProvisionedConcurrencyConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteProvisionedConcurrencyConfig", i0)
	r0, _ = returns[0].(*lambda.DeleteProvisionedConcurrencyConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) DeleteProvisionedConcurrencyConfigRequest(i0 *lambda.DeleteProvisionedConcurrencyConfigInput) (r0 *request.Request, r1 *lambda.DeleteProvisionedConcurrencyConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteProvisionedConcurrencyConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.DeleteProvisionedConcurrencyConfigOutput)
	return
}

func (d *LambdaDouble) DeleteProvisionedConcurrencyConfigWithContext(i0 context.Context, i1 *lambda.DeleteProvisionedConcurrencyConfigInput, i2 ...request.Option) (r0 *lambda.DeleteProvisionedConcurrencyConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteProvisionedConcurrencyConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.DeleteProvisionedConcurrencyConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeDeleteProvisionedConcurrencyConfigWithContext(ctx context.Context, in *lambda.DeleteProvisionedConcurrencyConfigInput, _ ...request.Option) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteProvisionedConcurrencyConfig cancelled", ctx.Err())
	default:
		return d.DeleteProvisionedConcurrencyConfig(in)
	}
}

func (d *LambdaDouble) GetAccountSettings(i0 *lambda.GetAccountSettingsInput) (r0 *lambda.GetAccountSettingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAccountSettings", i0)
	r0, _ = returns[0].(*lambda.GetAccountSettingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetAccountSettingsRequest(i0 *lambda.GetAccountSettingsInput) (r0 *request.Request, r1 *lambda.GetAccountSettingsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAccountSettingsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetAccountSettingsOutput)
	return
}

func (d *LambdaDouble) GetAccountSettingsWithContext(i0 context.Context, i1 *lambda.GetAccountSettingsInput, i2 ...request.Option) (r0 *lambda.GetAccountSettingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAccountSettingsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetAccountSettingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetAccountSettingsWithContext(ctx context.Context, in *lambda.GetAccountSettingsInput, _ ...request.Option) (*lambda.GetAccountSettingsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetAccountSettings cancelled", ctx.Err())
	default:
		return d.GetAccountSettings(in)
	}
}

func (d *LambdaDouble) GetAlias(i0 *lambda.GetAliasInput) (r0 *lambda.AliasConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAlias", i0)
	r0, _ = returns[0].(*lambda.AliasConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetAliasRequest(i0 *lambda.GetAliasInput) (r0 *request.Request, r1 *lambda.AliasConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAliasRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.AliasConfiguration)
	return
}

func (d *LambdaDouble) GetAliasWithContext(i0 context.Context, i1 *lambda.GetAliasInput, i2 ...request.Option) (r0 *lambda.AliasConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAliasWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.AliasConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetAliasWithContext(ctx context.Context, in *lambda.GetAliasInput, _ ...request.Option) (*lambda.AliasConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetAlias cancelled", ctx.Err())
	default:
		return d.GetAlias(in)
	}
}

func (d *LambdaDouble) GetEventSourceMapping(i0 *lambda.GetEventSourceMappingInput) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetEventSourceMapping", i0)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetEventSourceMappingRequest(i0 *lambda.GetEventSourceMappingInput) (r0 *request.Request, r1 *lambda.EventSourceMappingConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetEventSourceMappingRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.EventSourceMappingConfiguration)
	return
}

func (d *LambdaDouble) GetEventSourceMappingWithContext(i0 context.Context, i1 *lambda.GetEventSourceMappingInput, i2 ...request.Option) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetEventSourceMappingWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetEventSourceMappingWithContext(ctx context.Context, in *lambda.GetEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetEventSourceMapping cancelled", ctx.Err())
	default:
		return d.GetEventSourceMapping(in)
	}
}

func (d *LambdaDouble) GetFunction(i0 *lambda.GetFunctionInput) (r0 *lambda.GetFunctionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunction", i0)
	r0, _ = returns[0].(*lambda.GetFunctionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetFunctionConcurrency(i0 *lambda.GetFunctionConcurrencyInput) (r0 *lambda.GetFunctionConcurrencyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionConcurrency", i0)
	r0, _ = returns[0].(*lambda.GetFunctionConcurrencyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetFunctionConcurrencyRequest(i0 *lambda.GetFunctionConcurrencyInput) (r0 *request.Request, r1 *lambda.GetFunctionConcurrencyOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionConcurrencyRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetFunctionConcurrencyOutput)
	return
}

func (d *LambdaDouble) GetFunctionConcurrencyWithContext(i0 context.Context, i1 *lambda.GetFunctionConcurrencyInput, i2 ...request.Option) (r0 *lambda.GetFunctionConcurrencyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionConcurrencyWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetFunctionConcurrencyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetFunctionConcurrencyWithContext(ctx context.Context, in *lambda.GetFunctionConcurrencyInput, _ ...request.Option) (*lambda.GetFunctionConcurrencyOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetFunctionConcurrency cancelled", ctx.Err())
	default:
		return d.GetFunctionConcurrency(in)
	}
}

func (d *LambdaDouble) GetFunctionConfiguration(i0 *lambda.GetFunctionConfigurationInput) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionConfiguration", i0)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetFunctionConfigurationRequest(i0 *lambda.GetFunctionConfigurationInput) (r0 *request.Request, r1 *lambda.FunctionConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionConfigurationRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.FunctionConfiguration)
	return
}

func (d *LambdaDouble) GetFunctionConfigurationWithContext(i0 context.Context, i1 *lambda.GetFunctionConfigurationInput, i2 ...request.Option) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionConfigurationWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetFunctionConfigurationWithContext(ctx context.Context, in *lambda.GetFunctionConfigurationInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetFunctionConfiguration cancelled", ctx.Err())
	default:
		return d.GetFunctionConfiguration(in)
	}
}

func (d *LambdaDouble) GetFunctionEventInvokeConfig(i0 *lambda.GetFunctionEventInvokeConfigInput) (r0 *lambda.GetFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionEventInvokeConfig", i0)
	r0, _ = returns[0].(*lambda.GetFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetFunctionEventInvokeConfigRequest(i0 *lambda.GetFunctionEventInvokeConfigInput) (r0 *request.Request, r1 *lambda.GetFunctionEventInvokeConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionEventInvokeConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetFunctionEventInvokeConfigOutput)
	return
}

func (d *LambdaDouble) GetFunctionEventInvokeConfigWithContext(i0 context.Context, i1 *lambda.GetFunctionEventInvokeConfigInput, i2 ...request.Option) (r0 *lambda.GetFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionEventInvokeConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetFunctionEventInvokeConfigWithContext(ctx context.Context, in *lambda.GetFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.GetFunctionEventInvokeConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetFunctionEventInvokeConfig cancelled", ctx.Err())
	default:
		return d.GetFunctionEventInvokeConfig(in)
	}
}

func (d *LambdaDouble) GetFunctionRequest(i0 *lambda.GetFunctionInput) (r0 *request.Request, r1 *lambda.GetFunctionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetFunctionOutput)
	return
}

func (d *LambdaDouble) GetFunctionWithContext(i0 context.Context, i1 *lambda.GetFunctionInput, i2 ...request.Option) (r0 *lambda.GetFunctionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetFunctionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetFunctionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetFunctionWithContext(ctx context.Context, in *lambda.GetFunctionInput, _ ...request.Option) (*lambda.GetFunctionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetFunction cancelled", ctx.Err())
	default:
		return d.GetFunction(in)
	}
}

func (d *LambdaDouble) GetLayerVersion(i0 *lambda.GetLayerVersionInput) (r0 *lambda.GetLayerVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersion", i0)
	r0, _ = returns[0].(*lambda.GetLayerVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetLayerVersionByArn(i0 *lambda.GetLayerVersionByArnInput) (r0 *lambda.GetLayerVersionByArnOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionByArn", i0)
	r0, _ = returns[0].(*lambda.GetLayerVersionByArnOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetLayerVersionByArnRequest(i0 *lambda.GetLayerVersionByArnInput) (r0 *request.Request, r1 *lambda.GetLayerVersionByArnOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionByArnRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetLayerVersionByArnOutput)
	return
}

func (d *LambdaDouble) GetLayerVersionByArnWithContext(i0 context.Context, i1 *lambda.GetLayerVersionByArnInput, i2 ...request.Option) (r0 *lambda.GetLayerVersionByArnOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionByArnWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetLayerVersionByArnOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetLayerVersionByArnWithContext(ctx context.Context, in *lambda.GetLayerVersionByArnInput, _ ...request.Option) (*lambda.GetLayerVersionByArnOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetLayerVersionByArn cancelled", ctx.Err())
	default:
		return d.GetLayerVersionByArn(in)
	}
}

func (d *LambdaDouble) GetLayerVersionPolicy(i0 *lambda.GetLayerVersionPolicyInput) (r0 *lambda.GetLayerVersionPolicyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionPolicy", i0)
	r0, _ = returns[0].(*lambda.GetLayerVersionPolicyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetLayerVersionPolicyRequest(i0 *lambda.GetLayerVersionPolicyInput) (r0 *request.Request, r1 *lambda.GetLayerVersionPolicyOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionPolicyRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetLayerVersionPolicyOutput)
	return
}

func (d *LambdaDouble) GetLayerVersionPolicyWithContext(i0 context.Context, i1 *lambda.GetLayerVersionPolicyInput, i2 ...request.Option) (r0 *lambda.GetLayerVersionPolicyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionPolicyWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetLayerVersionPolicyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetLayerVersionPolicyWithContext(ctx context.Context, in *lambda.GetLayerVersionPolicyInput, _ ...request.Option) (*lambda.GetLayerVersionPolicyOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetLayerVersionPolicy cancelled", ctx.Err())
	default:
		return d.GetLayerVersionPolicy(in)
	}
}

func (d *LambdaDouble) GetLayerVersionRequest(i0 *lambda.GetLayerVersionInput) (r0 *request.Request, r1 *lambda.GetLayerVersionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetLayerVersionOutput)
	return
}

func (d *LambdaDouble) GetLayerVersionWithContext(i0 context.Context, i1 *lambda.GetLayerVersionInput, i2 ...request.Option) (r0 *lambda.GetLayerVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetLayerVersionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetLayerVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetLayerVersionWithContext(ctx context.Context, in *lambda.GetLayerVersionInput, _ ...request.Option) (*lambda.GetLayerVersionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetLayerVersion cancelled", ctx.Err())
	default:
		return d.GetLayerVersion(in)
	}
}

func (d *LambdaDouble) GetPolicy(i0 *lambda.GetPolicyInput) (r0 *lambda.GetPolicyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetPolicy", i0)
	r0, _ = returns[0].(*lambda.GetPolicyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetPolicyRequest(i0 *lambda.GetPolicyInput) (r0 *request.Request, r1 *lambda.GetPolicyOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetPolicyRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetPolicyOutput)
	return
}

func (d *LambdaDouble) GetPolicyWithContext(i0 context.Context, i1 *lambda.GetPolicyInput, i2 ...request.Option) (r0 *lambda.GetPolicyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetPolicyWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetPolicyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetPolicyWithContext(ctx context.Context, in *lambda.GetPolicyInput, _ ...request.Option) (*lambda.GetPolicyOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetPolicy cancelled", ctx.Err())
	default:
		return d.GetPolicy(in)
	}
}

func (d *LambdaDouble) GetProvisionedConcurrencyConfig(i0 *lambda.GetProvisionedConcurrencyConfigInput) (r0 *lambda.GetProvisionedConcurrencyConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetProvisionedConcurrencyConfig", i0)
	r0, _ = returns[0].(*lambda.GetProvisionedConcurrencyConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) GetProvisionedConcurrencyConfigRequest(i0 *lambda.GetProvisionedConcurrencyConfigInput) (r0 *request.Request, r1 *lambda.GetProvisionedConcurrencyConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetProvisionedConcurrencyConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.GetProvisionedConcurrencyConfigOutput)
	return
}

func (d *LambdaDouble) GetProvisionedConcurrencyConfigWithContext(i0 context.Context, i1 *lambda.GetProvisionedConcurrencyConfigInput, i2 ...request.Option) (r0 *lambda.GetProvisionedConcurrencyConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetProvisionedConcurrencyConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.GetProvisionedConcurrencyConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeGetProvisionedConcurrencyConfigWithContext(ctx context.Context, in *lambda.GetProvisionedConcurrencyConfigInput, _ ...request.Option) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "GetProvisionedConcurrencyConfig cancelled", ctx.Err())
	default:
		return d.GetProvisionedConcurrencyConfig(in)
	}
}

func (d *LambdaDouble) Invoke(i0 *lambda.InvokeInput) (r0 *lambda.InvokeOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("Invoke", i0)
	r0, _ = returns[0].(*lambda.InvokeOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) InvokeAsync(i0 *lambda.InvokeAsyncInput) (r0 *lambda.InvokeAsyncOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("InvokeAsync", i0)
	r0, _ = returns[0].(*lambda.InvokeAsyncOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) InvokeAsyncRequest(i0 *lambda.InvokeAsyncInput) (r0 *request.Request, r1 *lambda.InvokeAsyncOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("InvokeAsyncRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.InvokeAsyncOutput)
	return
}

func (d *LambdaDouble) InvokeAsyncWithContext(i0 context.Context, i1 *lambda.InvokeAsyncInput, i2 ...request.Option) (r0 *lambda.InvokeAsyncOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("InvokeAsyncWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.InvokeAsyncOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeInvokeAsyncWithContext(ctx context.Context, in *lambda.InvokeAsyncInput, _ ...request.Option) (*lambda.InvokeAsyncOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "InvokeAsync cancelled", ctx.Err())
	default:
		return d.InvokeAsync(in)
	}
}

func (d *LambdaDouble) InvokeRequest(i0 *lambda.InvokeInput) (r0 *request.Request, r1 *lambda.InvokeOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("InvokeRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.InvokeOutput)
	return
}

func (d *LambdaDouble) InvokeWithContext(i0 context.Context, i1 *lambda.InvokeInput, i2 ...request.Option) (r0 *lambda.InvokeOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("InvokeWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.InvokeOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeInvokeWithContext(ctx context.Context, in *lambda.InvokeInput, _ ...request.Option) (*lambda.InvokeOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "Invoke cancelled", ctx.Err())
	default:
		return d.Invoke(in)
	}
}

func (d *LambdaDouble) ListAliases(i0 *lambda.ListAliasesInput) (r0 *lambda.ListAliasesOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAliases", i0)
	r0, _ = returns[0].(*lambda.ListAliasesOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListAliasesPages(i0 *lambda.ListAliasesInput, i1 func(*lambda.ListAliasesOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAliasesPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListAliasesPages(in *lambda.ListAliasesInput, pager func(*lambda.ListAliasesOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListAliases", paginators, in, pager)
}

func (d *LambdaDouble) ListAliasesPagesWithContext(i0 context.Context, i1 *lambda.ListAliasesInput, i2 func(*lambda.ListAliasesOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAliasesPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListAliasesPagesWithContext(ctx context.Context, in *lambda.ListAliasesInput, pager func(*lambda.ListAliasesOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListAliases", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListAliasesRequest(i0 *lambda.ListAliasesInput) (r0 *request.Request, r1 *lambda.ListAliasesOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAliasesRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListAliasesOutput)
	return
}

func (d *LambdaDouble) ListAliasesWithContext(i0 context.Context, i1 *lambda.ListAliasesInput, i2 ...request.Option) (r0 *lambda.ListAliasesOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAliasesWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListAliasesOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListAliasesWithContext(ctx context.Context, in *lambda.ListAliasesInput, _ ...request.Option) (*lambda.ListAliasesOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListAliases cancelled", ctx.Err())
	default:
		return d.ListAliases(in)
	}
}

func (d *LambdaDouble) ListEventSourceMappings(i0 *lambda.ListEventSourceMappingsInput) (r0 *lambda.ListEventSourceMappingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListEventSourceMappings", i0)
	r0, _ = returns[0].(*lambda.ListEventSourceMappingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListEventSourceMappingsPages(i0 *lambda.ListEventSourceMappingsInput, i1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListEventSourceMappingsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListEventSourceMappingsPages(in *lambda.ListEventSourceMappingsInput, pager func(*lambda.ListEventSourceMappingsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListEventSourceMappings", paginators, in, pager)
}

func (d *LambdaDouble) ListEventSourceMappingsPagesWithContext(i0 context.Context, i1 *lambda.ListEventSourceMappingsInput, i2 func(*lambda.ListEventSourceMappingsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListEventSourceMappingsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListEventSourceMappingsPagesWithContext(ctx context.Context, in *lambda.ListEventSourceMappingsInput, pager func(*lambda.ListEventSourceMappingsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListEventSourceMappings", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListEventSourceMappingsRequest(i0 *lambda.ListEventSourceMappingsInput) (r0 *request.Request, r1 *lambda.ListEventSourceMappingsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListEventSourceMappingsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListEventSourceMappingsOutput)
	return
}

func (d *LambdaDouble) ListEventSourceMappingsWithContext(i0 context.Context, i1 *lambda.ListEventSourceMappingsInput, i2 ...request.Option) (r0 *lambda.ListEventSourceMappingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListEventSourceMappingsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListEventSourceMappingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListEventSourceMappingsWithContext(ctx context.Context, in *lambda.ListEventSourceMappingsInput, _ ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListEventSourceMappings cancelled", ctx.Err())
	default:
		return d.ListEventSourceMappings(in)
	}
}

func (d *LambdaDouble) ListFunctionEventInvokeConfigs(i0 *lambda.ListFunctionEventInvokeConfigsInput) (r0 *lambda.ListFunctionEventInvokeConfigsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionEventInvokeConfigs", i0)
	r0, _ = returns[0].(*lambda.ListFunctionEventInvokeConfigsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListFunctionEventInvokeConfigsPages(i0 *lambda.ListFunctionEventInvokeConfigsInput, i1 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionEventInvokeConfigsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListFunctionEventInvokeConfigsPages(in *lambda.ListFunctionEventInvokeConfigsInput, pager func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListFunctionEventInvokeConfigs", paginators, in, pager)
}

func (d *LambdaDouble) ListFunctionEventInvokeConfigsPagesWithContext(i0 context.Context, i1 *lambda.ListFunctionEventInvokeConfigsInput, i2 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionEventInvokeConfigsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListFunctionEventInvokeConfigsPagesWithContext(ctx context.Context, in *lambda.ListFunctionEventInvokeConfigsInput, pager func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListFunctionEventInvokeConfigs", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListFunctionEventInvokeConfigsRequest(i0 *lambda.ListFunctionEventInvokeConfigsInput) (r0 *request.Request, r1 *lambda.ListFunctionEventInvokeConfigsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionEventInvokeConfigsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListFunctionEventInvokeConfigsOutput)
	return
}

func (d *LambdaDouble) ListFunctionEventInvokeConfigsWithContext(i0 context.Context, i1 *lambda.ListFunctionEventInvokeConfigsInput, i2 ...request.Option) (r0 *lambda.ListFunctionEventInvokeConfigsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionEventInvokeConfigsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListFunctionEventInvokeConfigsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListFunctionEventInvokeConfigsWithContext(ctx context.Context, in *lambda.ListFunctionEventInvokeConfigsInput, _ ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListFunctionEventInvokeConfigs cancelled", ctx.Err())
	default:
		return d.ListFunctionEventInvokeConfigs(in)
	}
}

func (d *LambdaDouble) ListFunctions(i0 *lambda.ListFunctionsInput) (r0 *lambda.ListFunctionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctions", i0)
	r0, _ = returns[0].(*lambda.ListFunctionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListFunctionsPages(i0 *lambda.ListFunctionsInput, i1 func(*lambda.ListFunctionsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListFunctionsPages(in *lambda.ListFunctionsInput, pager func(*lambda.ListFunctionsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListFunctions", paginators, in, pager)
}

func (d *LambdaDouble) ListFunctionsPagesWithContext(i0 context.Context, i1 *lambda.ListFunctionsInput, i2 func(*lambda.ListFunctionsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListFunctionsPagesWithContext(ctx context.Context, in *lambda.ListFunctionsInput, pager func(*lambda.ListFunctionsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListFunctions", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListFunctionsRequest(i0 *lambda.ListFunctionsInput) (r0 *request.Request, r1 *lambda.ListFunctionsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListFunctionsOutput)
	return
}

func (d *LambdaDouble) ListFunctionsWithContext(i0 context.Context, i1 *lambda.ListFunctionsInput, i2 ...request.Option) (r0 *lambda.ListFunctionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListFunctionsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListFunctionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListFunctionsWithContext(ctx context.Context, in *lambda.ListFunctionsInput, _ ...request.Option) (*lambda.ListFunctionsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListFunctions cancelled", ctx.Err())
	default:
		return d.ListFunctions(in)
	}
}

func (d *LambdaDouble) ListLayerVersions(i0 *lambda.ListLayerVersionsInput) (r0 *lambda.ListLayerVersionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayerVersions", i0)
	r0, _ = returns[0].(*lambda.ListLayerVersionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListLayerVersionsPages(i0 *lambda.ListLayerVersionsInput, i1 func(*lambda.ListLayerVersionsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayerVersionsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListLayerVersionsPages(in *lambda.ListLayerVersionsInput, pager func(*lambda.ListLayerVersionsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListLayerVersions", paginators, in, pager)
}

func (d *LambdaDouble) ListLayerVersionsPagesWithContext(i0 context.Context, i1 *lambda.ListLayerVersionsInput, i2 func(*lambda.ListLayerVersionsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayerVersionsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListLayerVersionsPagesWithContext(ctx context.Context, in *lambda.ListLayerVersionsInput, pager func(*lambda.ListLayerVersionsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListLayerVersions", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListLayerVersionsRequest(i0 *lambda.ListLayerVersionsInput) (r0 *request.Request, r1 *lambda.ListLayerVersionsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayerVersionsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListLayerVersionsOutput)
	return
}

func (d *LambdaDouble) ListLayerVersionsWithContext(i0 context.Context, i1 *lambda.ListLayerVersionsInput, i2 ...request.Option) (r0 *lambda.ListLayerVersionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayerVersionsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListLayerVersionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListLayerVersionsWithContext(ctx context.Context, in *lambda.ListLayerVersionsInput, _ ...request.Option) (*lambda.ListLayerVersionsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListLayerVersions cancelled", ctx.Err())
	default:
		return d.ListLayerVersions(in)
	}
}

func (d *LambdaDouble) ListLayers(i0 *lambda.ListLayersInput) (r0 *lambda.ListLayersOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayers", i0)
	r0, _ = returns[0].(*lambda.ListLayersOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListLayersPages(i0 *lambda.ListLayersInput, i1 func(*lambda.ListLayersOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayersPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListLayersPages(in *lambda.ListLayersInput, pager func(*lambda.ListLayersOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListLayers", paginators, in, pager)
}

func (d *LambdaDouble) ListLayersPagesWithContext(i0 context.Context, i1 *lambda.ListLayersInput, i2 func(*lambda.ListLayersOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayersPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListLayersPagesWithContext(ctx context.Context, in *lambda.ListLayersInput, pager func(*lambda.ListLayersOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListLayers", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListLayersRequest(i0 *lambda.ListLayersInput) (r0 *request.Request, r1 *lambda.ListLayersOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayersRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListLayersOutput)
	return
}

func (d *LambdaDouble) ListLayersWithContext(i0 context.Context, i1 *lambda.ListLayersInput, i2 ...request.Option) (r0 *lambda.ListLayersOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLayersWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListLayersOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListLayersWithContext(ctx context.Context, in *lambda.ListLayersInput, _ ...request.Option) (*lambda.ListLayersOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListLayers cancelled", ctx.Err())
	default:
		return d.ListLayers(in)
	}
}

func (d *LambdaDouble) ListProvisionedConcurrencyConfigs(i0 *lambda.ListProvisionedConcurrencyConfigsInput) (r0 *lambda.ListProvisionedConcurrencyConfigsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProvisionedConcurrencyConfigs", i0)
	r0, _ = returns[0].(*lambda.ListProvisionedConcurrencyConfigsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListProvisionedConcurrencyConfigsPages(i0 *lambda.ListProvisionedConcurrencyConfigsInput, i1 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProvisionedConcurrencyConfigsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListProvisionedConcurrencyConfigsPages(in *lambda.ListProvisionedConcurrencyConfigsInput, pager func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListProvisionedConcurrencyConfigs", paginators, in, pager)
}

func (d *LambdaDouble) ListProvisionedConcurrencyConfigsPagesWithContext(i0 context.Context, i1 *lambda.ListProvisionedConcurrencyConfigsInput, i2 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProvisionedConcurrencyConfigsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListProvisionedConcurrencyConfigsPagesWithContext(ctx context.Context, in *lambda.ListProvisionedConcurrencyConfigsInput, pager func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListProvisionedConcurrencyConfigs", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListProvisionedConcurrencyConfigsRequest(i0 *lambda.ListProvisionedConcurrencyConfigsInput) (r0 *request.Request, r1 *lambda.ListProvisionedConcurrencyConfigsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProvisionedConcurrencyConfigsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListProvisionedConcurrencyConfigsOutput)
	return
}

func (d *LambdaDouble) ListProvisionedConcurrencyConfigsWithContext(i0 context.Context, i1 *lambda.ListProvisionedConcurrencyConfigsInput, i2 ...request.Option) (r0 *lambda.ListProvisionedConcurrencyConfigsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProvisionedConcurrencyConfigsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListProvisionedConcurrencyConfigsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListProvisionedConcurrencyConfigsWithContext(ctx context.Context, in *lambda.ListProvisionedConcurrencyConfigsInput, _ ...request.Option) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListProvisionedConcurrencyConfigs cancelled", ctx.Err())
	default:
		return d.ListProvisionedConcurrencyConfigs(in)
	}
}

func (d *LambdaDouble) ListTags(i0 *lambda.ListTagsInput) (r0 *lambda.ListTagsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTags", i0)
	r0, _ = returns[0].(*lambda.ListTagsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListTagsRequest(i0 *lambda.ListTagsInput) (r0 *request.Request, r1 *lambda.ListTagsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListTagsOutput)
	return
}

func (d *LambdaDouble) ListTagsWithContext(i0 context.Context, i1 *lambda.ListTagsInput, i2 ...request.Option) (r0 *lambda.ListTagsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListTagsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListTagsWithContext(ctx context.Context, in *lambda.ListTagsInput, _ ...request.Option) (*lambda.ListTagsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListTags cancelled", ctx.Err())
	default:
		return d.ListTags(in)
	}
}

func (d *LambdaDouble) ListVersionsByFunction(i0 *lambda.ListVersionsByFunctionInput) (r0 *lambda.ListVersionsByFunctionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListVersionsByFunction", i0)
	r0, _ = returns[0].(*lambda.ListVersionsByFunctionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) ListVersionsByFunctionPages(i0 *lambda.ListVersionsByFunctionInput, i1 func(*lambda.ListVersionsByFunctionOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListVersionsByFunctionPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListVersionsByFunctionPages(in *lambda.ListVersionsByFunctionInput, pager func(*lambda.ListVersionsByFunctionOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListVersionsByFunction", paginators, in, pager)
}

func (d *LambdaDouble) ListVersionsByFunctionPagesWithContext(i0 context.Context, i1 *lambda.ListVersionsByFunctionInput, i2 func(*lambda.ListVersionsByFunctionOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListVersionsByFunctionPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeListVersionsByFunctionPagesWithContext(ctx context.Context, in *lambda.ListVersionsByFunctionInput, pager func(*lambda.ListVersionsByFunctionOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListVersionsByFunction", paginators, ctx, in, pager, options...)
}

func (d *LambdaDouble) ListVersionsByFunctionRequest(i0 *lambda.ListVersionsByFunctionInput) (r0 *request.Request, r1 *lambda.ListVersionsByFunctionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListVersionsByFunctionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.ListVersionsByFunctionOutput)
	return
}

func (d *LambdaDouble) ListVersionsByFunctionWithContext(i0 context.Context, i1 *lambda.ListVersionsByFunctionInput, i2 ...request.Option) (r0 *lambda.ListVersionsByFunctionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListVersionsByFunctionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.ListVersionsByFunctionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeListVersionsByFunctionWithContext(ctx context.Context, in *lambda.ListVersionsByFunctionInput, _ ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListVersionsByFunction cancelled", ctx.Err())
	default:
		return d.ListVersionsByFunction(in)
	}
}

func (d *LambdaDouble) PublishLayerVersion(i0 *lambda.PublishLayerVersionInput) (r0 *lambda.PublishLayerVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PublishLayerVersion", i0)
	r0, _ = returns[0].(*lambda.PublishLayerVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) PublishLayerVersionRequest(i0 *lambda.PublishLayerVersionInput) (r0 *request.Request, r1 *lambda.PublishLayerVersionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PublishLayerVersionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.PublishLayerVersionOutput)
	return
}

func (d *LambdaDouble) PublishLayerVersionWithContext(i0 context.Context, i1 *lambda.PublishLayerVersionInput, i2 ...request.Option) (r0 *lambda.PublishLayerVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PublishLayerVersionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.PublishLayerVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakePublishLayerVersionWithContext(ctx context.Context, in *lambda.PublishLayerVersionInput, _ ...request.Option) (*lambda.PublishLayerVersionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "PublishLayerVersion cancelled", ctx.Err())
	default:
		return d.PublishLayerVersion(in)
	}
}

func (d *LambdaDouble) PublishVersion(i0 *lambda.PublishVersionInput) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PublishVersion", i0)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) PublishVersionRequest(i0 *lambda.PublishVersionInput) (r0 *request.Request, r1 *lambda.FunctionConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PublishVersionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.FunctionConfiguration)
	return
}

func (d *LambdaDouble) PublishVersionWithContext(i0 context.Context, i1 *lambda.PublishVersionInput, i2 ...request.Option) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PublishVersionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakePublishVersionWithContext(ctx context.Context, in *lambda.PublishVersionInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "PublishVersion cancelled", ctx.Err())
	default:
		return d.PublishVersion(in)
	}
}

func (d *LambdaDouble) PutFunctionConcurrency(i0 *lambda.PutFunctionConcurrencyInput) (r0 *lambda.PutFunctionConcurrencyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutFunctionConcurrency", i0)
	r0, _ = returns[0].(*lambda.PutFunctionConcurrencyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) PutFunctionConcurrencyRequest(i0 *lambda.PutFunctionConcurrencyInput) (r0 *request.Request, r1 *lambda.PutFunctionConcurrencyOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutFunctionConcurrencyRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.PutFunctionConcurrencyOutput)
	return
}

func (d *LambdaDouble) PutFunctionConcurrencyWithContext(i0 context.Context, i1 *lambda.PutFunctionConcurrencyInput, i2 ...request.Option) (r0 *lambda.PutFunctionConcurrencyOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutFunctionConcurrencyWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.PutFunctionConcurrencyOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakePutFunctionConcurrencyWithContext(ctx context.Context, in *lambda.PutFunctionConcurrencyInput, _ ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "PutFunctionConcurrency cancelled", ctx.Err())
	default:
		return d.PutFunctionConcurrency(in)
	}
}

func (d *LambdaDouble) PutFunctionEventInvokeConfig(i0 *lambda.PutFunctionEventInvokeConfigInput) (r0 *lambda.PutFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutFunctionEventInvokeConfig", i0)
	r0, _ = returns[0].(*lambda.PutFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) PutFunctionEventInvokeConfigRequest(i0 *lambda.PutFunctionEventInvokeConfigInput) (r0 *request.Request, r1 *lambda.PutFunctionEventInvokeConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutFunctionEventInvokeConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.PutFunctionEventInvokeConfigOutput)
	return
}

func (d *LambdaDouble) PutFunctionEventInvokeConfigWithContext(i0 context.Context, i1 *lambda.PutFunctionEventInvokeConfigInput, i2 ...request.Option) (r0 *lambda.PutFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutFunctionEventInvokeConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.PutFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakePutFunctionEventInvokeConfigWithContext(ctx context.Context, in *lambda.PutFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.PutFunctionEventInvokeConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "PutFunctionEventInvokeConfig cancelled", ctx.Err())
	default:
		return d.PutFunctionEventInvokeConfig(in)
	}
}

func (d *LambdaDouble) PutProvisionedConcurrencyConfig(i0 *lambda.PutProvisionedConcurrencyConfigInput) (r0 *lambda.PutProvisionedConcurrencyConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutProvisionedConcurrencyConfig", i0)
	r0, _ = returns[0].(*lambda.PutProvisionedConcurrencyConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) PutProvisionedConcurrencyConfigRequest(i0 *lambda.PutProvisionedConcurrencyConfigInput) (r0 *request.Request, r1 *lambda.PutProvisionedConcurrencyConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutProvisionedConcurrencyConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.PutProvisionedConcurrencyConfigOutput)
	return
}

func (d *LambdaDouble) PutProvisionedConcurrencyConfigWithContext(i0 context.Context, i1 *lambda.PutProvisionedConcurrencyConfigInput, i2 ...request.Option) (r0 *lambda.PutProvisionedConcurrencyConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutProvisionedConcurrencyConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.PutProvisionedConcurrencyConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakePutProvisionedConcurrencyConfigWithContext(ctx context.Context, in *lambda.PutProvisionedConcurrencyConfigInput, _ ...request.Option) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "PutProvisionedConcurrencyConfig cancelled", ctx.Err())
	default:
		return d.PutProvisionedConcurrencyConfig(in)
	}
}

func (d *LambdaDouble) RemoveLayerVersionPermission(i0 *lambda.RemoveLayerVersionPermissionInput) (r0 *lambda.RemoveLayerVersionPermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("RemoveLayerVersionPermission", i0)
	r0, _ = returns[0].(*lambda.RemoveLayerVersionPermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) RemoveLayerVersionPermissionRequest(i0 *lambda.RemoveLayerVersionPermissionInput) (r0 *request.Request, r1 *lambda.RemoveLayerVersionPermissionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("RemoveLayerVersionPermissionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.RemoveLayerVersionPermissionOutput)
	return
}

func (d *LambdaDouble) RemoveLayerVersionPermissionWithContext(i0 context.Context, i1 *lambda.RemoveLayerVersionPermissionInput, i2 ...request.Option) (r0 *lambda.RemoveLayerVersionPermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("RemoveLayerVersionPermissionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.RemoveLayerVersionPermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeRemoveLayerVersionPermissionWithContext(ctx context.Context, in *lambda.RemoveLayerVersionPermissionInput, _ ...request.Option) (*lambda.RemoveLayerVersionPermissionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "RemoveLayerVersionPermission cancelled", ctx.Err())
	default:
		return d.RemoveLayerVersionPermission(in)
	}
}

func (d *LambdaDouble) RemovePermission(i0 *lambda.RemovePermissionInput) (r0 *lambda.RemovePermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("RemovePermission", i0)
	r0, _ = returns[0].(*lambda.RemovePermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) RemovePermissionRequest(i0 *lambda.RemovePermissionInput) (r0 *request.Request, r1 *lambda.RemovePermissionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("RemovePermissionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.RemovePermissionOutput)
	return
}

func (d *LambdaDouble) RemovePermissionWithContext(i0 context.Context, i1 *lambda.RemovePermissionInput, i2 ...request.Option) (r0 *lambda.RemovePermissionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("RemovePermissionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.RemovePermissionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeRemovePermissionWithContext(ctx context.Context, in *lambda.RemovePermissionInput, _ ...request.Option) (*lambda.RemovePermissionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "RemovePermission cancelled", ctx.Err())
	default:
		return d.RemovePermission(in)
	}
}

func (d *LambdaDouble) TagResource(i0 *lambda.TagResourceInput) (r0 *lambda.TagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("TagResource", i0)
	r0, _ = returns[0].(*lambda.TagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) TagResourceRequest(i0 *lambda.TagResourceInput) (r0 *request.Request, r1 *lambda.TagResourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("TagResourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.TagResourceOutput)
	return
}

func (d *LambdaDouble) TagResourceWithContext(i0 context.Context, i1 *lambda.TagResourceInput, i2 ...request.Option) (r0 *lambda.TagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("TagResourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.TagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeTagResourceWithContext(ctx context.Context, in *lambda.TagResourceInput, _ ...request.Option) (*lambda.TagResourceOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "TagResource cancelled", ctx.Err())
	default:
		return d.TagResource(in)
	}
}

func (d *LambdaDouble) UntagResource(i0 *lambda.UntagResourceInput) (r0 *lambda.UntagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UntagResource", i0)
	r0, _ = returns[0].(*lambda.UntagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) UntagResourceRequest(i0 *lambda.UntagResourceInput) (r0 *request.Request, r1 *lambda.UntagResourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UntagResourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.UntagResourceOutput)
	return
}

func (d *LambdaDouble) UntagResourceWithContext(i0 context.Context, i1 *lambda.UntagResourceInput, i2 ...request.Option) (r0 *lambda.UntagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UntagResourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.UntagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeUntagResourceWithContext(ctx context.Context, in *lambda.UntagResourceInput, _ ...request.Option) (*lambda.UntagResourceOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UntagResource cancelled", ctx.Err())
	default:
		return d.UntagResource(in)
	}
}

func (d *LambdaDouble) UpdateAlias(i0 *lambda.UpdateAliasInput) (r0 *lambda.AliasConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAlias", i0)
	r0, _ = returns[0].(*lambda.AliasConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) UpdateAliasRequest(i0 *lambda.UpdateAliasInput) (r0 *request.Request, r1 *lambda.AliasConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAliasRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.AliasConfiguration)
	return
}

func (d *LambdaDouble) UpdateAliasWithContext(i0 context.Context, i1 *lambda.UpdateAliasInput, i2 ...request.Option) (r0 *lambda.AliasConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAliasWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.AliasConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeUpdateAliasWithContext(ctx context.Context, in *lambda.UpdateAliasInput, _ ...request.Option) (*lambda.AliasConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateAlias cancelled", ctx.Err())
	default:
		return d.UpdateAlias(in)
	}
}

func (d *LambdaDouble) UpdateEventSourceMapping(i0 *lambda.UpdateEventSourceMappingInput) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateEventSourceMapping", i0)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) UpdateEventSourceMappingRequest(i0 *lambda.UpdateEventSourceMappingInput) (r0 *request.Request, r1 *lambda.EventSourceMappingConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateEventSourceMappingRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.EventSourceMappingConfiguration)
	return
}

func (d *LambdaDouble) UpdateEventSourceMappingWithContext(i0 context.Context, i1 *lambda.UpdateEventSourceMappingInput, i2 ...request.Option) (r0 *lambda.EventSourceMappingConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateEventSourceMappingWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.EventSourceMappingConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeUpdateEventSourceMappingWithContext(ctx context.Context, in *lambda.UpdateEventSourceMappingInput, _ ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateEventSourceMapping cancelled", ctx.Err())
	default:
		return d.UpdateEventSourceMapping(in)
	}
}

func (d *LambdaDouble) UpdateFunctionCode(i0 *lambda.UpdateFunctionCodeInput) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionCode", i0)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) UpdateFunctionCodeRequest(i0 *lambda.UpdateFunctionCodeInput) (r0 *request.Request, r1 *lambda.FunctionConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionCodeRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.FunctionConfiguration)
	return
}

func (d *LambdaDouble) UpdateFunctionCodeWithContext(i0 context.Context, i1 *lambda.UpdateFunctionCodeInput, i2 ...request.Option) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionCodeWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeUpdateFunctionCodeWithContext(ctx context.Context, in *lambda.UpdateFunctionCodeInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateFunctionCode cancelled", ctx.Err())
	default:
		return d.UpdateFunctionCode(in)
	}
}

func (d *LambdaDouble) UpdateFunctionConfiguration(i0 *lambda.UpdateFunctionConfigurationInput) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionConfiguration", i0)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) UpdateFunctionConfigurationRequest(i0 *lambda.UpdateFunctionConfigurationInput) (r0 *request.Request, r1 *lambda.FunctionConfiguration) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionConfigurationRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.FunctionConfiguration)
	return
}

func (d *LambdaDouble) UpdateFunctionConfigurationWithContext(i0 context.Context, i1 *lambda.UpdateFunctionConfigurationInput, i2 ...request.Option) (r0 *lambda.FunctionConfiguration, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionConfigurationWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.FunctionConfiguration)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeUpdateFunctionConfigurationWithContext(ctx context.Context, in *lambda.UpdateFunctionConfigurationInput, _ ...request.Option) (*lambda.FunctionConfiguration, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateFunctionConfiguration cancelled", ctx.Err())
	default:
		return d.UpdateFunctionConfiguration(in)
	}
}

func (d *LambdaDouble) UpdateFunctionEventInvokeConfig(i0 *lambda.UpdateFunctionEventInvokeConfigInput) (r0 *lambda.UpdateFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionEventInvokeConfig", i0)
	r0, _ = returns[0].(*lambda.UpdateFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) UpdateFunctionEventInvokeConfigRequest(i0 *lambda.UpdateFunctionEventInvokeConfigInput) (r0 *request.Request, r1 *lambda.UpdateFunctionEventInvokeConfigOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionEventInvokeConfigRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*lambda.UpdateFunctionEventInvokeConfigOutput)
	return
}

func (d *LambdaDouble) UpdateFunctionEventInvokeConfigWithContext(i0 context.Context, i1 *lambda.UpdateFunctionEventInvokeConfigInput, i2 ...request.Option) (r0 *lambda.UpdateFunctionEventInvokeConfigOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateFunctionEventInvokeConfigWithContext", i0, i1, i2)
	r0, _ = returns[0].(*lambda.UpdateFunctionEventInvokeConfigOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *LambdaDouble) fakeUpdateFunctionEventInvokeConfigWithContext(ctx context.Context, in *lambda.UpdateFunctionEventInvokeConfigInput, _ ...request.Option) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateFunctionEventInvokeConfig cancelled", ctx.Err())
	default:
		return d.UpdateFunctionEventInvokeConfig(in)
	}
}

func (d *LambdaDouble) WaitUntilFunctionActive(i0 *lambda.GetFunctionConfigurationInput) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilFunctionActive", i0)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeWaitUntilFunctionActive(in *lambda.GetFunctionConfigurationInput) error {
	return d.WaitUntil("FunctionActive", waiters, in)
}

func (d *LambdaDouble) WaitUntilFunctionActiveWithContext(i0 context.Context, i1 *lambda.GetFunctionConfigurationInput, i2 ...request.WaiterOption) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilFunctionActiveWithContext", i0, i1, i2)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeWaitUntilFunctionActiveWithContext(ctx context.Context, in *lambda.GetFunctionConfigurationInput, waitOption ...request.WaiterOption) error {
	return d.WaitWithContext("FunctionActive", waiters, ctx, in, waitOption...)
}

func (d *LambdaDouble) WaitUntilFunctionExists(i0 *lambda.GetFunctionInput) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilFunctionExists", i0)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeWaitUntilFunctionExists(in *lambda.GetFunctionInput) error {
	return d.WaitUntil("FunctionExists", waiters, in)
}

func (d *LambdaDouble) WaitUntilFunctionExistsWithContext(i0 context.Context, i1 *lambda.GetFunctionInput, i2 ...request.WaiterOption) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilFunctionExistsWithContext", i0, i1, i2)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeWaitUntilFunctionExistsWithContext(ctx context.Context, in *lambda.GetFunctionInput, waitOption ...request.WaiterOption) error {
	return d.WaitWithContext("FunctionExists", waiters, ctx, in, waitOption...)
}

func (d *LambdaDouble) WaitUntilFunctionUpdated(i0 *lambda.GetFunctionConfigurationInput) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilFunctionUpdated", i0)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeWaitUntilFunctionUpdated(in *lambda.GetFunctionConfigurationInput) error {
	return d.WaitUntil("FunctionUpdated", waiters, in)
}

func (d *LambdaDouble) WaitUntilFunctionUpdatedWithContext(i0 context.Context, i1 *lambda.GetFunctionConfigurationInput, i2 ...request.WaiterOption) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilFunctionUpdatedWithContext", i0, i1, i2)
	r0, _ = returns[0].(error)
	return
}

func (d *LambdaDouble) fakeWaitUntilFunctionUpdatedWithContext(ctx context.Context, in *lambda.GetFunctionConfigurationInput, waitOption ...request.WaiterOption) error {
	return d.WaitWithContext("FunctionUpdated", waiters, ctx, in, waitOption...)
}