double.go

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

// Package schemasdouble provides a TestDouble implementation of schemasiface.SchemasAPI
package schemasdouble

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

// SchemasDouble is TestDouble for schemasiface.SchemasAPI
type SchemasDouble struct {
	schemasiface.SchemasAPI
	*awsdouble.AWSTestDouble
}

// Constructor for SchemasDouble
// 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)) *SchemasDouble {
	result := &SchemasDouble{}

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

	result.AWSTestDouble = awsdouble.NewDouble(t, (*schemasiface.SchemasAPI)(nil), configurators...)
	return result
}

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

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

	case "CreateDiscovererWithContext":
		return m.Fake(d.fakeCreateDiscovererWithContext)

	case "CreateRegistryWithContext":
		return m.Fake(d.fakeCreateRegistryWithContext)

	case "CreateSchemaWithContext":
		return m.Fake(d.fakeCreateSchemaWithContext)

	case "DeleteDiscovererWithContext":
		return m.Fake(d.fakeDeleteDiscovererWithContext)

	case "DeleteRegistryWithContext":
		return m.Fake(d.fakeDeleteRegistryWithContext)

	case "DeleteSchemaVersionWithContext":
		return m.Fake(d.fakeDeleteSchemaVersionWithContext)

	case "DeleteSchemaWithContext":
		return m.Fake(d.fakeDeleteSchemaWithContext)

	case "DescribeCodeBindingWithContext":
		return m.Fake(d.fakeDescribeCodeBindingWithContext)

	case "DescribeDiscovererWithContext":
		return m.Fake(d.fakeDescribeDiscovererWithContext)

	case "DescribeRegistryWithContext":
		return m.Fake(d.fakeDescribeRegistryWithContext)

	case "DescribeSchemaWithContext":
		return m.Fake(d.fakeDescribeSchemaWithContext)

	case "GetCodeBindingSourceWithContext":
		return m.Fake(d.fakeGetCodeBindingSourceWithContext)

	case "GetDiscoveredSchemaWithContext":
		return m.Fake(d.fakeGetDiscoveredSchemaWithContext)

	case "ListDiscoverersPages":
		return m.Fake(d.fakeListDiscoverersPages)

	case "ListDiscoverersPagesWithContext":
		return m.Fake(d.fakeListDiscoverersPagesWithContext)

	case "ListDiscoverersWithContext":
		return m.Fake(d.fakeListDiscoverersWithContext)

	case "ListRegistriesPages":
		return m.Fake(d.fakeListRegistriesPages)

	case "ListRegistriesPagesWithContext":
		return m.Fake(d.fakeListRegistriesPagesWithContext)

	case "ListRegistriesWithContext":
		return m.Fake(d.fakeListRegistriesWithContext)

	case "ListSchemaVersionsPages":
		return m.Fake(d.fakeListSchemaVersionsPages)

	case "ListSchemaVersionsPagesWithContext":
		return m.Fake(d.fakeListSchemaVersionsPagesWithContext)

	case "ListSchemaVersionsWithContext":
		return m.Fake(d.fakeListSchemaVersionsWithContext)

	case "ListSchemasPages":
		return m.Fake(d.fakeListSchemasPages)

	case "ListSchemasPagesWithContext":
		return m.Fake(d.fakeListSchemasPagesWithContext)

	case "ListSchemasWithContext":
		return m.Fake(d.fakeListSchemasWithContext)

	case "ListTagsForResourceWithContext":
		return m.Fake(d.fakeListTagsForResourceWithContext)

	case "LockServiceLinkedRoleWithContext":
		return m.Fake(d.fakeLockServiceLinkedRoleWithContext)

	case "PutCodeBindingWithContext":
		return m.Fake(d.fakePutCodeBindingWithContext)

	case "SearchSchemasPages":
		return m.Fake(d.fakeSearchSchemasPages)

	case "SearchSchemasPagesWithContext":
		return m.Fake(d.fakeSearchSchemasPagesWithContext)

	case "SearchSchemasWithContext":
		return m.Fake(d.fakeSearchSchemasWithContext)

	case "StartDiscovererWithContext":
		return m.Fake(d.fakeStartDiscovererWithContext)

	case "StopDiscovererWithContext":
		return m.Fake(d.fakeStopDiscovererWithContext)

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

	case "UnlockServiceLinkedRoleWithContext":
		return m.Fake(d.fakeUnlockServiceLinkedRoleWithContext)

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

	case "UpdateDiscovererWithContext":
		return m.Fake(d.fakeUpdateDiscovererWithContext)

	case "UpdateRegistryWithContext":
		return m.Fake(d.fakeUpdateRegistryWithContext)

	case "UpdateSchemaWithContext":
		return m.Fake(d.fakeUpdateSchemaWithContext)

	case "WaitUntilCodeBindingExists":
		return m.Fake(d.fakeWaitUntilCodeBindingExists)

	case "WaitUntilCodeBindingExistsWithContext":
		return m.Fake(d.fakeWaitUntilCodeBindingExistsWithContext)

	default:
		return nil
	}
}

func (d *SchemasDouble) CreateDiscoverer(i0 *schemas.CreateDiscovererInput) (r0 *schemas.CreateDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDiscoverer", i0)
	r0, _ = returns[0].(*schemas.CreateDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) CreateDiscovererRequest(i0 *schemas.CreateDiscovererInput) (r0 *request.Request, r1 *schemas.CreateDiscovererOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDiscovererRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.CreateDiscovererOutput)
	return
}

func (d *SchemasDouble) CreateDiscovererWithContext(i0 context.Context, i1 *schemas.CreateDiscovererInput, i2 ...request.Option) (r0 *schemas.CreateDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDiscovererWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.CreateDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeCreateDiscovererWithContext(ctx context.Context, in *schemas.CreateDiscovererInput, _ ...request.Option) (*schemas.CreateDiscovererOutput, error) {

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

func (d *SchemasDouble) CreateRegistry(i0 *schemas.CreateRegistryInput) (r0 *schemas.CreateRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateRegistry", i0)
	r0, _ = returns[0].(*schemas.CreateRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) CreateRegistryRequest(i0 *schemas.CreateRegistryInput) (r0 *request.Request, r1 *schemas.CreateRegistryOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateRegistryRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.CreateRegistryOutput)
	return
}

func (d *SchemasDouble) CreateRegistryWithContext(i0 context.Context, i1 *schemas.CreateRegistryInput, i2 ...request.Option) (r0 *schemas.CreateRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateRegistryWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.CreateRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeCreateRegistryWithContext(ctx context.Context, in *schemas.CreateRegistryInput, _ ...request.Option) (*schemas.CreateRegistryOutput, error) {

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

func (d *SchemasDouble) CreateSchema(i0 *schemas.CreateSchemaInput) (r0 *schemas.CreateSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateSchema", i0)
	r0, _ = returns[0].(*schemas.CreateSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) CreateSchemaRequest(i0 *schemas.CreateSchemaInput) (r0 *request.Request, r1 *schemas.CreateSchemaOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateSchemaRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.CreateSchemaOutput)
	return
}

func (d *SchemasDouble) CreateSchemaWithContext(i0 context.Context, i1 *schemas.CreateSchemaInput, i2 ...request.Option) (r0 *schemas.CreateSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateSchemaWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.CreateSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeCreateSchemaWithContext(ctx context.Context, in *schemas.CreateSchemaInput, _ ...request.Option) (*schemas.CreateSchemaOutput, error) {

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

func (d *SchemasDouble) DeleteDiscoverer(i0 *schemas.DeleteDiscovererInput) (r0 *schemas.DeleteDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDiscoverer", i0)
	r0, _ = returns[0].(*schemas.DeleteDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DeleteDiscovererRequest(i0 *schemas.DeleteDiscovererInput) (r0 *request.Request, r1 *schemas.DeleteDiscovererOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDiscovererRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DeleteDiscovererOutput)
	return
}

func (d *SchemasDouble) DeleteDiscovererWithContext(i0 context.Context, i1 *schemas.DeleteDiscovererInput, i2 ...request.Option) (r0 *schemas.DeleteDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDiscovererWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DeleteDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDeleteDiscovererWithContext(ctx context.Context, in *schemas.DeleteDiscovererInput, _ ...request.Option) (*schemas.DeleteDiscovererOutput, error) {

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

func (d *SchemasDouble) DeleteRegistry(i0 *schemas.DeleteRegistryInput) (r0 *schemas.DeleteRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteRegistry", i0)
	r0, _ = returns[0].(*schemas.DeleteRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DeleteRegistryRequest(i0 *schemas.DeleteRegistryInput) (r0 *request.Request, r1 *schemas.DeleteRegistryOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteRegistryRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DeleteRegistryOutput)
	return
}

func (d *SchemasDouble) DeleteRegistryWithContext(i0 context.Context, i1 *schemas.DeleteRegistryInput, i2 ...request.Option) (r0 *schemas.DeleteRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteRegistryWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DeleteRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDeleteRegistryWithContext(ctx context.Context, in *schemas.DeleteRegistryInput, _ ...request.Option) (*schemas.DeleteRegistryOutput, error) {

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

func (d *SchemasDouble) DeleteSchema(i0 *schemas.DeleteSchemaInput) (r0 *schemas.DeleteSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSchema", i0)
	r0, _ = returns[0].(*schemas.DeleteSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DeleteSchemaRequest(i0 *schemas.DeleteSchemaInput) (r0 *request.Request, r1 *schemas.DeleteSchemaOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSchemaRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DeleteSchemaOutput)
	return
}

func (d *SchemasDouble) DeleteSchemaVersion(i0 *schemas.DeleteSchemaVersionInput) (r0 *schemas.DeleteSchemaVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSchemaVersion", i0)
	r0, _ = returns[0].(*schemas.DeleteSchemaVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DeleteSchemaVersionRequest(i0 *schemas.DeleteSchemaVersionInput) (r0 *request.Request, r1 *schemas.DeleteSchemaVersionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSchemaVersionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DeleteSchemaVersionOutput)
	return
}

func (d *SchemasDouble) DeleteSchemaVersionWithContext(i0 context.Context, i1 *schemas.DeleteSchemaVersionInput, i2 ...request.Option) (r0 *schemas.DeleteSchemaVersionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSchemaVersionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DeleteSchemaVersionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDeleteSchemaVersionWithContext(ctx context.Context, in *schemas.DeleteSchemaVersionInput, _ ...request.Option) (*schemas.DeleteSchemaVersionOutput, error) {

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

func (d *SchemasDouble) DeleteSchemaWithContext(i0 context.Context, i1 *schemas.DeleteSchemaInput, i2 ...request.Option) (r0 *schemas.DeleteSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSchemaWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DeleteSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDeleteSchemaWithContext(ctx context.Context, in *schemas.DeleteSchemaInput, _ ...request.Option) (*schemas.DeleteSchemaOutput, error) {

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

func (d *SchemasDouble) DescribeCodeBinding(i0 *schemas.DescribeCodeBindingInput) (r0 *schemas.DescribeCodeBindingOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeCodeBinding", i0)
	r0, _ = returns[0].(*schemas.DescribeCodeBindingOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DescribeCodeBindingRequest(i0 *schemas.DescribeCodeBindingInput) (r0 *request.Request, r1 *schemas.DescribeCodeBindingOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeCodeBindingRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DescribeCodeBindingOutput)
	return
}

func (d *SchemasDouble) DescribeCodeBindingWithContext(i0 context.Context, i1 *schemas.DescribeCodeBindingInput, i2 ...request.Option) (r0 *schemas.DescribeCodeBindingOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeCodeBindingWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DescribeCodeBindingOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDescribeCodeBindingWithContext(ctx context.Context, in *schemas.DescribeCodeBindingInput, _ ...request.Option) (*schemas.DescribeCodeBindingOutput, error) {

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

func (d *SchemasDouble) DescribeDiscoverer(i0 *schemas.DescribeDiscovererInput) (r0 *schemas.DescribeDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDiscoverer", i0)
	r0, _ = returns[0].(*schemas.DescribeDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DescribeDiscovererRequest(i0 *schemas.DescribeDiscovererInput) (r0 *request.Request, r1 *schemas.DescribeDiscovererOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDiscovererRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DescribeDiscovererOutput)
	return
}

func (d *SchemasDouble) DescribeDiscovererWithContext(i0 context.Context, i1 *schemas.DescribeDiscovererInput, i2 ...request.Option) (r0 *schemas.DescribeDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDiscovererWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DescribeDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDescribeDiscovererWithContext(ctx context.Context, in *schemas.DescribeDiscovererInput, _ ...request.Option) (*schemas.DescribeDiscovererOutput, error) {

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

func (d *SchemasDouble) DescribeRegistry(i0 *schemas.DescribeRegistryInput) (r0 *schemas.DescribeRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeRegistry", i0)
	r0, _ = returns[0].(*schemas.DescribeRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DescribeRegistryRequest(i0 *schemas.DescribeRegistryInput) (r0 *request.Request, r1 *schemas.DescribeRegistryOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeRegistryRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DescribeRegistryOutput)
	return
}

func (d *SchemasDouble) DescribeRegistryWithContext(i0 context.Context, i1 *schemas.DescribeRegistryInput, i2 ...request.Option) (r0 *schemas.DescribeRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeRegistryWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DescribeRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDescribeRegistryWithContext(ctx context.Context, in *schemas.DescribeRegistryInput, _ ...request.Option) (*schemas.DescribeRegistryOutput, error) {

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

func (d *SchemasDouble) DescribeSchema(i0 *schemas.DescribeSchemaInput) (r0 *schemas.DescribeSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeSchema", i0)
	r0, _ = returns[0].(*schemas.DescribeSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) DescribeSchemaRequest(i0 *schemas.DescribeSchemaInput) (r0 *request.Request, r1 *schemas.DescribeSchemaOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeSchemaRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.DescribeSchemaOutput)
	return
}

func (d *SchemasDouble) DescribeSchemaWithContext(i0 context.Context, i1 *schemas.DescribeSchemaInput, i2 ...request.Option) (r0 *schemas.DescribeSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeSchemaWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.DescribeSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeDescribeSchemaWithContext(ctx context.Context, in *schemas.DescribeSchemaInput, _ ...request.Option) (*schemas.DescribeSchemaOutput, error) {

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

func (d *SchemasDouble) GetCodeBindingSource(i0 *schemas.GetCodeBindingSourceInput) (r0 *schemas.GetCodeBindingSourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetCodeBindingSource", i0)
	r0, _ = returns[0].(*schemas.GetCodeBindingSourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) GetCodeBindingSourceRequest(i0 *schemas.GetCodeBindingSourceInput) (r0 *request.Request, r1 *schemas.GetCodeBindingSourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetCodeBindingSourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.GetCodeBindingSourceOutput)
	return
}

func (d *SchemasDouble) GetCodeBindingSourceWithContext(i0 context.Context, i1 *schemas.GetCodeBindingSourceInput, i2 ...request.Option) (r0 *schemas.GetCodeBindingSourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetCodeBindingSourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.GetCodeBindingSourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeGetCodeBindingSourceWithContext(ctx context.Context, in *schemas.GetCodeBindingSourceInput, _ ...request.Option) (*schemas.GetCodeBindingSourceOutput, error) {

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

func (d *SchemasDouble) GetDiscoveredSchema(i0 *schemas.GetDiscoveredSchemaInput) (r0 *schemas.GetDiscoveredSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetDiscoveredSchema", i0)
	r0, _ = returns[0].(*schemas.GetDiscoveredSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) GetDiscoveredSchemaRequest(i0 *schemas.GetDiscoveredSchemaInput) (r0 *request.Request, r1 *schemas.GetDiscoveredSchemaOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetDiscoveredSchemaRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.GetDiscoveredSchemaOutput)
	return
}

func (d *SchemasDouble) GetDiscoveredSchemaWithContext(i0 context.Context, i1 *schemas.GetDiscoveredSchemaInput, i2 ...request.Option) (r0 *schemas.GetDiscoveredSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetDiscoveredSchemaWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.GetDiscoveredSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeGetDiscoveredSchemaWithContext(ctx context.Context, in *schemas.GetDiscoveredSchemaInput, _ ...request.Option) (*schemas.GetDiscoveredSchemaOutput, error) {

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

func (d *SchemasDouble) ListDiscoverers(i0 *schemas.ListDiscoverersInput) (r0 *schemas.ListDiscoverersOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDiscoverers", i0)
	r0, _ = returns[0].(*schemas.ListDiscoverersOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) ListDiscoverersPages(i0 *schemas.ListDiscoverersInput, i1 func(*schemas.ListDiscoverersOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDiscoverersPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListDiscoverersPages(in *schemas.ListDiscoverersInput, pager func(*schemas.ListDiscoverersOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListDiscoverers", paginators, in, pager)
}

func (d *SchemasDouble) ListDiscoverersPagesWithContext(i0 context.Context, i1 *schemas.ListDiscoverersInput, i2 func(*schemas.ListDiscoverersOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDiscoverersPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListDiscoverersPagesWithContext(ctx context.Context, in *schemas.ListDiscoverersInput, pager func(*schemas.ListDiscoverersOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListDiscoverers", paginators, ctx, in, pager, options...)
}

func (d *SchemasDouble) ListDiscoverersRequest(i0 *schemas.ListDiscoverersInput) (r0 *request.Request, r1 *schemas.ListDiscoverersOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDiscoverersRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.ListDiscoverersOutput)
	return
}

func (d *SchemasDouble) ListDiscoverersWithContext(i0 context.Context, i1 *schemas.ListDiscoverersInput, i2 ...request.Option) (r0 *schemas.ListDiscoverersOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDiscoverersWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.ListDiscoverersOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeListDiscoverersWithContext(ctx context.Context, in *schemas.ListDiscoverersInput, _ ...request.Option) (*schemas.ListDiscoverersOutput, error) {

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

func (d *SchemasDouble) ListRegistries(i0 *schemas.ListRegistriesInput) (r0 *schemas.ListRegistriesOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRegistries", i0)
	r0, _ = returns[0].(*schemas.ListRegistriesOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) ListRegistriesPages(i0 *schemas.ListRegistriesInput, i1 func(*schemas.ListRegistriesOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRegistriesPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListRegistriesPages(in *schemas.ListRegistriesInput, pager func(*schemas.ListRegistriesOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListRegistries", paginators, in, pager)
}

func (d *SchemasDouble) ListRegistriesPagesWithContext(i0 context.Context, i1 *schemas.ListRegistriesInput, i2 func(*schemas.ListRegistriesOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRegistriesPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListRegistriesPagesWithContext(ctx context.Context, in *schemas.ListRegistriesInput, pager func(*schemas.ListRegistriesOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListRegistries", paginators, ctx, in, pager, options...)
}

func (d *SchemasDouble) ListRegistriesRequest(i0 *schemas.ListRegistriesInput) (r0 *request.Request, r1 *schemas.ListRegistriesOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRegistriesRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.ListRegistriesOutput)
	return
}

func (d *SchemasDouble) ListRegistriesWithContext(i0 context.Context, i1 *schemas.ListRegistriesInput, i2 ...request.Option) (r0 *schemas.ListRegistriesOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRegistriesWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.ListRegistriesOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeListRegistriesWithContext(ctx context.Context, in *schemas.ListRegistriesInput, _ ...request.Option) (*schemas.ListRegistriesOutput, error) {

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

func (d *SchemasDouble) ListSchemaVersions(i0 *schemas.ListSchemaVersionsInput) (r0 *schemas.ListSchemaVersionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemaVersions", i0)
	r0, _ = returns[0].(*schemas.ListSchemaVersionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) ListSchemaVersionsPages(i0 *schemas.ListSchemaVersionsInput, i1 func(*schemas.ListSchemaVersionsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemaVersionsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListSchemaVersionsPages(in *schemas.ListSchemaVersionsInput, pager func(*schemas.ListSchemaVersionsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListSchemaVersions", paginators, in, pager)
}

func (d *SchemasDouble) ListSchemaVersionsPagesWithContext(i0 context.Context, i1 *schemas.ListSchemaVersionsInput, i2 func(*schemas.ListSchemaVersionsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemaVersionsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListSchemaVersionsPagesWithContext(ctx context.Context, in *schemas.ListSchemaVersionsInput, pager func(*schemas.ListSchemaVersionsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListSchemaVersions", paginators, ctx, in, pager, options...)
}

func (d *SchemasDouble) ListSchemaVersionsRequest(i0 *schemas.ListSchemaVersionsInput) (r0 *request.Request, r1 *schemas.ListSchemaVersionsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemaVersionsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.ListSchemaVersionsOutput)
	return
}

func (d *SchemasDouble) ListSchemaVersionsWithContext(i0 context.Context, i1 *schemas.ListSchemaVersionsInput, i2 ...request.Option) (r0 *schemas.ListSchemaVersionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemaVersionsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.ListSchemaVersionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeListSchemaVersionsWithContext(ctx context.Context, in *schemas.ListSchemaVersionsInput, _ ...request.Option) (*schemas.ListSchemaVersionsOutput, error) {

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

func (d *SchemasDouble) ListSchemas(i0 *schemas.ListSchemasInput) (r0 *schemas.ListSchemasOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemas", i0)
	r0, _ = returns[0].(*schemas.ListSchemasOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) ListSchemasPages(i0 *schemas.ListSchemasInput, i1 func(*schemas.ListSchemasOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemasPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListSchemasPages(in *schemas.ListSchemasInput, pager func(*schemas.ListSchemasOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListSchemas", paginators, in, pager)
}

func (d *SchemasDouble) ListSchemasPagesWithContext(i0 context.Context, i1 *schemas.ListSchemasInput, i2 func(*schemas.ListSchemasOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemasPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeListSchemasPagesWithContext(ctx context.Context, in *schemas.ListSchemasInput, pager func(*schemas.ListSchemasOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListSchemas", paginators, ctx, in, pager, options...)
}

func (d *SchemasDouble) ListSchemasRequest(i0 *schemas.ListSchemasInput) (r0 *request.Request, r1 *schemas.ListSchemasOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemasRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.ListSchemasOutput)
	return
}

func (d *SchemasDouble) ListSchemasWithContext(i0 context.Context, i1 *schemas.ListSchemasInput, i2 ...request.Option) (r0 *schemas.ListSchemasOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListSchemasWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.ListSchemasOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeListSchemasWithContext(ctx context.Context, in *schemas.ListSchemasInput, _ ...request.Option) (*schemas.ListSchemasOutput, error) {

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

func (d *SchemasDouble) ListTagsForResource(i0 *schemas.ListTagsForResourceInput) (r0 *schemas.ListTagsForResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResource", i0)
	r0, _ = returns[0].(*schemas.ListTagsForResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) ListTagsForResourceRequest(i0 *schemas.ListTagsForResourceInput) (r0 *request.Request, r1 *schemas.ListTagsForResourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.ListTagsForResourceOutput)
	return
}

func (d *SchemasDouble) ListTagsForResourceWithContext(i0 context.Context, i1 *schemas.ListTagsForResourceInput, i2 ...request.Option) (r0 *schemas.ListTagsForResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.ListTagsForResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeListTagsForResourceWithContext(ctx context.Context, in *schemas.ListTagsForResourceInput, _ ...request.Option) (*schemas.ListTagsForResourceOutput, error) {

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

func (d *SchemasDouble) LockServiceLinkedRole(i0 *schemas.LockServiceLinkedRoleInput) (r0 *schemas.LockServiceLinkedRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("LockServiceLinkedRole", i0)
	r0, _ = returns[0].(*schemas.LockServiceLinkedRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) LockServiceLinkedRoleRequest(i0 *schemas.LockServiceLinkedRoleInput) (r0 *request.Request, r1 *schemas.LockServiceLinkedRoleOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("LockServiceLinkedRoleRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.LockServiceLinkedRoleOutput)
	return
}

func (d *SchemasDouble) LockServiceLinkedRoleWithContext(i0 context.Context, i1 *schemas.LockServiceLinkedRoleInput, i2 ...request.Option) (r0 *schemas.LockServiceLinkedRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("LockServiceLinkedRoleWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.LockServiceLinkedRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeLockServiceLinkedRoleWithContext(ctx context.Context, in *schemas.LockServiceLinkedRoleInput, _ ...request.Option) (*schemas.LockServiceLinkedRoleOutput, error) {

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

func (d *SchemasDouble) PutCodeBinding(i0 *schemas.PutCodeBindingInput) (r0 *schemas.PutCodeBindingOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutCodeBinding", i0)
	r0, _ = returns[0].(*schemas.PutCodeBindingOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) PutCodeBindingRequest(i0 *schemas.PutCodeBindingInput) (r0 *request.Request, r1 *schemas.PutCodeBindingOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutCodeBindingRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.PutCodeBindingOutput)
	return
}

func (d *SchemasDouble) PutCodeBindingWithContext(i0 context.Context, i1 *schemas.PutCodeBindingInput, i2 ...request.Option) (r0 *schemas.PutCodeBindingOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("PutCodeBindingWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.PutCodeBindingOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakePutCodeBindingWithContext(ctx context.Context, in *schemas.PutCodeBindingInput, _ ...request.Option) (*schemas.PutCodeBindingOutput, error) {

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

func (d *SchemasDouble) SearchSchemas(i0 *schemas.SearchSchemasInput) (r0 *schemas.SearchSchemasOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("SearchSchemas", i0)
	r0, _ = returns[0].(*schemas.SearchSchemasOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) SearchSchemasPages(i0 *schemas.SearchSchemasInput, i1 func(*schemas.SearchSchemasOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("SearchSchemasPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeSearchSchemasPages(in *schemas.SearchSchemasInput, pager func(*schemas.SearchSchemasOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("SearchSchemas", paginators, in, pager)
}

func (d *SchemasDouble) SearchSchemasPagesWithContext(i0 context.Context, i1 *schemas.SearchSchemasInput, i2 func(*schemas.SearchSchemasOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("SearchSchemasPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeSearchSchemasPagesWithContext(ctx context.Context, in *schemas.SearchSchemasInput, pager func(*schemas.SearchSchemasOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("SearchSchemas", paginators, ctx, in, pager, options...)
}

func (d *SchemasDouble) SearchSchemasRequest(i0 *schemas.SearchSchemasInput) (r0 *request.Request, r1 *schemas.SearchSchemasOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("SearchSchemasRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.SearchSchemasOutput)
	return
}

func (d *SchemasDouble) SearchSchemasWithContext(i0 context.Context, i1 *schemas.SearchSchemasInput, i2 ...request.Option) (r0 *schemas.SearchSchemasOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("SearchSchemasWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.SearchSchemasOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeSearchSchemasWithContext(ctx context.Context, in *schemas.SearchSchemasInput, _ ...request.Option) (*schemas.SearchSchemasOutput, error) {

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

func (d *SchemasDouble) StartDiscoverer(i0 *schemas.StartDiscovererInput) (r0 *schemas.StartDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartDiscoverer", i0)
	r0, _ = returns[0].(*schemas.StartDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) StartDiscovererRequest(i0 *schemas.StartDiscovererInput) (r0 *request.Request, r1 *schemas.StartDiscovererOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartDiscovererRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.StartDiscovererOutput)
	return
}

func (d *SchemasDouble) StartDiscovererWithContext(i0 context.Context, i1 *schemas.StartDiscovererInput, i2 ...request.Option) (r0 *schemas.StartDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartDiscovererWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.StartDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeStartDiscovererWithContext(ctx context.Context, in *schemas.StartDiscovererInput, _ ...request.Option) (*schemas.StartDiscovererOutput, error) {

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

func (d *SchemasDouble) StopDiscoverer(i0 *schemas.StopDiscovererInput) (r0 *schemas.StopDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StopDiscoverer", i0)
	r0, _ = returns[0].(*schemas.StopDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) StopDiscovererRequest(i0 *schemas.StopDiscovererInput) (r0 *request.Request, r1 *schemas.StopDiscovererOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StopDiscovererRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.StopDiscovererOutput)
	return
}

func (d *SchemasDouble) StopDiscovererWithContext(i0 context.Context, i1 *schemas.StopDiscovererInput, i2 ...request.Option) (r0 *schemas.StopDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StopDiscovererWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.StopDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeStopDiscovererWithContext(ctx context.Context, in *schemas.StopDiscovererInput, _ ...request.Option) (*schemas.StopDiscovererOutput, error) {

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

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

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

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

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

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

func (d *SchemasDouble) UnlockServiceLinkedRole(i0 *schemas.UnlockServiceLinkedRoleInput) (r0 *schemas.UnlockServiceLinkedRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UnlockServiceLinkedRole", i0)
	r0, _ = returns[0].(*schemas.UnlockServiceLinkedRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) UnlockServiceLinkedRoleRequest(i0 *schemas.UnlockServiceLinkedRoleInput) (r0 *request.Request, r1 *schemas.UnlockServiceLinkedRoleOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UnlockServiceLinkedRoleRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.UnlockServiceLinkedRoleOutput)
	return
}

func (d *SchemasDouble) UnlockServiceLinkedRoleWithContext(i0 context.Context, i1 *schemas.UnlockServiceLinkedRoleInput, i2 ...request.Option) (r0 *schemas.UnlockServiceLinkedRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UnlockServiceLinkedRoleWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.UnlockServiceLinkedRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeUnlockServiceLinkedRoleWithContext(ctx context.Context, in *schemas.UnlockServiceLinkedRoleInput, _ ...request.Option) (*schemas.UnlockServiceLinkedRoleOutput, error) {

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

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

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

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

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

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

func (d *SchemasDouble) UpdateDiscoverer(i0 *schemas.UpdateDiscovererInput) (r0 *schemas.UpdateDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDiscoverer", i0)
	r0, _ = returns[0].(*schemas.UpdateDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) UpdateDiscovererRequest(i0 *schemas.UpdateDiscovererInput) (r0 *request.Request, r1 *schemas.UpdateDiscovererOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDiscovererRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.UpdateDiscovererOutput)
	return
}

func (d *SchemasDouble) UpdateDiscovererWithContext(i0 context.Context, i1 *schemas.UpdateDiscovererInput, i2 ...request.Option) (r0 *schemas.UpdateDiscovererOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDiscovererWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.UpdateDiscovererOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeUpdateDiscovererWithContext(ctx context.Context, in *schemas.UpdateDiscovererInput, _ ...request.Option) (*schemas.UpdateDiscovererOutput, error) {

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

func (d *SchemasDouble) UpdateRegistry(i0 *schemas.UpdateRegistryInput) (r0 *schemas.UpdateRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateRegistry", i0)
	r0, _ = returns[0].(*schemas.UpdateRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) UpdateRegistryRequest(i0 *schemas.UpdateRegistryInput) (r0 *request.Request, r1 *schemas.UpdateRegistryOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateRegistryRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.UpdateRegistryOutput)
	return
}

func (d *SchemasDouble) UpdateRegistryWithContext(i0 context.Context, i1 *schemas.UpdateRegistryInput, i2 ...request.Option) (r0 *schemas.UpdateRegistryOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateRegistryWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.UpdateRegistryOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeUpdateRegistryWithContext(ctx context.Context, in *schemas.UpdateRegistryInput, _ ...request.Option) (*schemas.UpdateRegistryOutput, error) {

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

func (d *SchemasDouble) UpdateSchema(i0 *schemas.UpdateSchemaInput) (r0 *schemas.UpdateSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateSchema", i0)
	r0, _ = returns[0].(*schemas.UpdateSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) UpdateSchemaRequest(i0 *schemas.UpdateSchemaInput) (r0 *request.Request, r1 *schemas.UpdateSchemaOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateSchemaRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*schemas.UpdateSchemaOutput)
	return
}

func (d *SchemasDouble) UpdateSchemaWithContext(i0 context.Context, i1 *schemas.UpdateSchemaInput, i2 ...request.Option) (r0 *schemas.UpdateSchemaOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateSchemaWithContext", i0, i1, i2)
	r0, _ = returns[0].(*schemas.UpdateSchemaOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *SchemasDouble) fakeUpdateSchemaWithContext(ctx context.Context, in *schemas.UpdateSchemaInput, _ ...request.Option) (*schemas.UpdateSchemaOutput, error) {

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

func (d *SchemasDouble) WaitUntilCodeBindingExists(i0 *schemas.DescribeCodeBindingInput) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilCodeBindingExists", i0)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeWaitUntilCodeBindingExists(in *schemas.DescribeCodeBindingInput) error {
	return d.WaitUntil("CodeBindingExists", waiters, in)
}

func (d *SchemasDouble) WaitUntilCodeBindingExistsWithContext(i0 context.Context, i1 *schemas.DescribeCodeBindingInput, i2 ...request.WaiterOption) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("WaitUntilCodeBindingExistsWithContext", i0, i1, i2)
	r0, _ = returns[0].(error)
	return
}

func (d *SchemasDouble) fakeWaitUntilCodeBindingExistsWithContext(ctx context.Context, in *schemas.DescribeCodeBindingInput, waitOption ...request.WaiterOption) error {
	return d.WaitWithContext("CodeBindingExists", waiters, ctx, in, waitOption...)
}