double.go

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

// Package forecastservicedouble provides a TestDouble implementation of forecastserviceiface.ForecastServiceAPI
package forecastservicedouble

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

// ForecastServiceDouble is TestDouble for forecastserviceiface.ForecastServiceAPI
type ForecastServiceDouble struct {
	forecastserviceiface.ForecastServiceAPI
	*awsdouble.AWSTestDouble
}

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

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

	result.AWSTestDouble = awsdouble.NewDouble(t, (*forecastserviceiface.ForecastServiceAPI)(nil), configurators...)
	return result
}

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

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

	case "CreateDatasetGroupWithContext":
		return m.Fake(d.fakeCreateDatasetGroupWithContext)

	case "CreateDatasetImportJobWithContext":
		return m.Fake(d.fakeCreateDatasetImportJobWithContext)

	case "CreateDatasetWithContext":
		return m.Fake(d.fakeCreateDatasetWithContext)

	case "CreateForecastExportJobWithContext":
		return m.Fake(d.fakeCreateForecastExportJobWithContext)

	case "CreateForecastWithContext":
		return m.Fake(d.fakeCreateForecastWithContext)

	case "CreatePredictorWithContext":
		return m.Fake(d.fakeCreatePredictorWithContext)

	case "DeleteDatasetGroupWithContext":
		return m.Fake(d.fakeDeleteDatasetGroupWithContext)

	case "DeleteDatasetImportJobWithContext":
		return m.Fake(d.fakeDeleteDatasetImportJobWithContext)

	case "DeleteDatasetWithContext":
		return m.Fake(d.fakeDeleteDatasetWithContext)

	case "DeleteForecastExportJobWithContext":
		return m.Fake(d.fakeDeleteForecastExportJobWithContext)

	case "DeleteForecastWithContext":
		return m.Fake(d.fakeDeleteForecastWithContext)

	case "DeletePredictorWithContext":
		return m.Fake(d.fakeDeletePredictorWithContext)

	case "DescribeDatasetGroupWithContext":
		return m.Fake(d.fakeDescribeDatasetGroupWithContext)

	case "DescribeDatasetImportJobWithContext":
		return m.Fake(d.fakeDescribeDatasetImportJobWithContext)

	case "DescribeDatasetWithContext":
		return m.Fake(d.fakeDescribeDatasetWithContext)

	case "DescribeForecastExportJobWithContext":
		return m.Fake(d.fakeDescribeForecastExportJobWithContext)

	case "DescribeForecastWithContext":
		return m.Fake(d.fakeDescribeForecastWithContext)

	case "DescribePredictorWithContext":
		return m.Fake(d.fakeDescribePredictorWithContext)

	case "GetAccuracyMetricsWithContext":
		return m.Fake(d.fakeGetAccuracyMetricsWithContext)

	case "ListDatasetGroupsPages":
		return m.Fake(d.fakeListDatasetGroupsPages)

	case "ListDatasetGroupsPagesWithContext":
		return m.Fake(d.fakeListDatasetGroupsPagesWithContext)

	case "ListDatasetGroupsWithContext":
		return m.Fake(d.fakeListDatasetGroupsWithContext)

	case "ListDatasetImportJobsPages":
		return m.Fake(d.fakeListDatasetImportJobsPages)

	case "ListDatasetImportJobsPagesWithContext":
		return m.Fake(d.fakeListDatasetImportJobsPagesWithContext)

	case "ListDatasetImportJobsWithContext":
		return m.Fake(d.fakeListDatasetImportJobsWithContext)

	case "ListDatasetsPages":
		return m.Fake(d.fakeListDatasetsPages)

	case "ListDatasetsPagesWithContext":
		return m.Fake(d.fakeListDatasetsPagesWithContext)

	case "ListDatasetsWithContext":
		return m.Fake(d.fakeListDatasetsWithContext)

	case "ListForecastExportJobsPages":
		return m.Fake(d.fakeListForecastExportJobsPages)

	case "ListForecastExportJobsPagesWithContext":
		return m.Fake(d.fakeListForecastExportJobsPagesWithContext)

	case "ListForecastExportJobsWithContext":
		return m.Fake(d.fakeListForecastExportJobsWithContext)

	case "ListForecastsPages":
		return m.Fake(d.fakeListForecastsPages)

	case "ListForecastsPagesWithContext":
		return m.Fake(d.fakeListForecastsPagesWithContext)

	case "ListForecastsWithContext":
		return m.Fake(d.fakeListForecastsWithContext)

	case "ListPredictorsPages":
		return m.Fake(d.fakeListPredictorsPages)

	case "ListPredictorsPagesWithContext":
		return m.Fake(d.fakeListPredictorsPagesWithContext)

	case "ListPredictorsWithContext":
		return m.Fake(d.fakeListPredictorsWithContext)

	case "UpdateDatasetGroupWithContext":
		return m.Fake(d.fakeUpdateDatasetGroupWithContext)

	default:
		return nil
	}
}

func (d *ForecastServiceDouble) CreateDataset(i0 *forecastservice.CreateDatasetInput) (r0 *forecastservice.CreateDatasetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDataset", i0)
	r0, _ = returns[0].(*forecastservice.CreateDatasetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) CreateDatasetGroup(i0 *forecastservice.CreateDatasetGroupInput) (r0 *forecastservice.CreateDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetGroup", i0)
	r0, _ = returns[0].(*forecastservice.CreateDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) CreateDatasetGroupRequest(i0 *forecastservice.CreateDatasetGroupInput) (r0 *request.Request, r1 *forecastservice.CreateDatasetGroupOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetGroupRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.CreateDatasetGroupOutput)
	return
}

func (d *ForecastServiceDouble) CreateDatasetGroupWithContext(i0 context.Context, i1 *forecastservice.CreateDatasetGroupInput, i2 ...request.Option) (r0 *forecastservice.CreateDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetGroupWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.CreateDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeCreateDatasetGroupWithContext(ctx context.Context, in *forecastservice.CreateDatasetGroupInput, _ ...request.Option) (*forecastservice.CreateDatasetGroupOutput, error) {

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

func (d *ForecastServiceDouble) CreateDatasetImportJob(i0 *forecastservice.CreateDatasetImportJobInput) (r0 *forecastservice.CreateDatasetImportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetImportJob", i0)
	r0, _ = returns[0].(*forecastservice.CreateDatasetImportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) CreateDatasetImportJobRequest(i0 *forecastservice.CreateDatasetImportJobInput) (r0 *request.Request, r1 *forecastservice.CreateDatasetImportJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetImportJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.CreateDatasetImportJobOutput)
	return
}

func (d *ForecastServiceDouble) CreateDatasetImportJobWithContext(i0 context.Context, i1 *forecastservice.CreateDatasetImportJobInput, i2 ...request.Option) (r0 *forecastservice.CreateDatasetImportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetImportJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.CreateDatasetImportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeCreateDatasetImportJobWithContext(ctx context.Context, in *forecastservice.CreateDatasetImportJobInput, _ ...request.Option) (*forecastservice.CreateDatasetImportJobOutput, error) {

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

func (d *ForecastServiceDouble) CreateDatasetRequest(i0 *forecastservice.CreateDatasetInput) (r0 *request.Request, r1 *forecastservice.CreateDatasetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.CreateDatasetOutput)
	return
}

func (d *ForecastServiceDouble) CreateDatasetWithContext(i0 context.Context, i1 *forecastservice.CreateDatasetInput, i2 ...request.Option) (r0 *forecastservice.CreateDatasetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDatasetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.CreateDatasetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeCreateDatasetWithContext(ctx context.Context, in *forecastservice.CreateDatasetInput, _ ...request.Option) (*forecastservice.CreateDatasetOutput, error) {

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

func (d *ForecastServiceDouble) CreateForecast(i0 *forecastservice.CreateForecastInput) (r0 *forecastservice.CreateForecastOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateForecast", i0)
	r0, _ = returns[0].(*forecastservice.CreateForecastOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) CreateForecastExportJob(i0 *forecastservice.CreateForecastExportJobInput) (r0 *forecastservice.CreateForecastExportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateForecastExportJob", i0)
	r0, _ = returns[0].(*forecastservice.CreateForecastExportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) CreateForecastExportJobRequest(i0 *forecastservice.CreateForecastExportJobInput) (r0 *request.Request, r1 *forecastservice.CreateForecastExportJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateForecastExportJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.CreateForecastExportJobOutput)
	return
}

func (d *ForecastServiceDouble) CreateForecastExportJobWithContext(i0 context.Context, i1 *forecastservice.CreateForecastExportJobInput, i2 ...request.Option) (r0 *forecastservice.CreateForecastExportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateForecastExportJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.CreateForecastExportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeCreateForecastExportJobWithContext(ctx context.Context, in *forecastservice.CreateForecastExportJobInput, _ ...request.Option) (*forecastservice.CreateForecastExportJobOutput, error) {

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

func (d *ForecastServiceDouble) CreateForecastRequest(i0 *forecastservice.CreateForecastInput) (r0 *request.Request, r1 *forecastservice.CreateForecastOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateForecastRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.CreateForecastOutput)
	return
}

func (d *ForecastServiceDouble) CreateForecastWithContext(i0 context.Context, i1 *forecastservice.CreateForecastInput, i2 ...request.Option) (r0 *forecastservice.CreateForecastOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateForecastWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.CreateForecastOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeCreateForecastWithContext(ctx context.Context, in *forecastservice.CreateForecastInput, _ ...request.Option) (*forecastservice.CreateForecastOutput, error) {

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

func (d *ForecastServiceDouble) CreatePredictor(i0 *forecastservice.CreatePredictorInput) (r0 *forecastservice.CreatePredictorOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreatePredictor", i0)
	r0, _ = returns[0].(*forecastservice.CreatePredictorOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) CreatePredictorRequest(i0 *forecastservice.CreatePredictorInput) (r0 *request.Request, r1 *forecastservice.CreatePredictorOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreatePredictorRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.CreatePredictorOutput)
	return
}

func (d *ForecastServiceDouble) CreatePredictorWithContext(i0 context.Context, i1 *forecastservice.CreatePredictorInput, i2 ...request.Option) (r0 *forecastservice.CreatePredictorOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreatePredictorWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.CreatePredictorOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeCreatePredictorWithContext(ctx context.Context, in *forecastservice.CreatePredictorInput, _ ...request.Option) (*forecastservice.CreatePredictorOutput, error) {

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

func (d *ForecastServiceDouble) DeleteDataset(i0 *forecastservice.DeleteDatasetInput) (r0 *forecastservice.DeleteDatasetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDataset", i0)
	r0, _ = returns[0].(*forecastservice.DeleteDatasetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DeleteDatasetGroup(i0 *forecastservice.DeleteDatasetGroupInput) (r0 *forecastservice.DeleteDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetGroup", i0)
	r0, _ = returns[0].(*forecastservice.DeleteDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DeleteDatasetGroupRequest(i0 *forecastservice.DeleteDatasetGroupInput) (r0 *request.Request, r1 *forecastservice.DeleteDatasetGroupOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetGroupRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DeleteDatasetGroupOutput)
	return
}

func (d *ForecastServiceDouble) DeleteDatasetGroupWithContext(i0 context.Context, i1 *forecastservice.DeleteDatasetGroupInput, i2 ...request.Option) (r0 *forecastservice.DeleteDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetGroupWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DeleteDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDeleteDatasetGroupWithContext(ctx context.Context, in *forecastservice.DeleteDatasetGroupInput, _ ...request.Option) (*forecastservice.DeleteDatasetGroupOutput, error) {

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

func (d *ForecastServiceDouble) DeleteDatasetImportJob(i0 *forecastservice.DeleteDatasetImportJobInput) (r0 *forecastservice.DeleteDatasetImportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetImportJob", i0)
	r0, _ = returns[0].(*forecastservice.DeleteDatasetImportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DeleteDatasetImportJobRequest(i0 *forecastservice.DeleteDatasetImportJobInput) (r0 *request.Request, r1 *forecastservice.DeleteDatasetImportJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetImportJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DeleteDatasetImportJobOutput)
	return
}

func (d *ForecastServiceDouble) DeleteDatasetImportJobWithContext(i0 context.Context, i1 *forecastservice.DeleteDatasetImportJobInput, i2 ...request.Option) (r0 *forecastservice.DeleteDatasetImportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetImportJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DeleteDatasetImportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDeleteDatasetImportJobWithContext(ctx context.Context, in *forecastservice.DeleteDatasetImportJobInput, _ ...request.Option) (*forecastservice.DeleteDatasetImportJobOutput, error) {

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

func (d *ForecastServiceDouble) DeleteDatasetRequest(i0 *forecastservice.DeleteDatasetInput) (r0 *request.Request, r1 *forecastservice.DeleteDatasetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DeleteDatasetOutput)
	return
}

func (d *ForecastServiceDouble) DeleteDatasetWithContext(i0 context.Context, i1 *forecastservice.DeleteDatasetInput, i2 ...request.Option) (r0 *forecastservice.DeleteDatasetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDatasetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DeleteDatasetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDeleteDatasetWithContext(ctx context.Context, in *forecastservice.DeleteDatasetInput, _ ...request.Option) (*forecastservice.DeleteDatasetOutput, error) {

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

func (d *ForecastServiceDouble) DeleteForecast(i0 *forecastservice.DeleteForecastInput) (r0 *forecastservice.DeleteForecastOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteForecast", i0)
	r0, _ = returns[0].(*forecastservice.DeleteForecastOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DeleteForecastExportJob(i0 *forecastservice.DeleteForecastExportJobInput) (r0 *forecastservice.DeleteForecastExportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteForecastExportJob", i0)
	r0, _ = returns[0].(*forecastservice.DeleteForecastExportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DeleteForecastExportJobRequest(i0 *forecastservice.DeleteForecastExportJobInput) (r0 *request.Request, r1 *forecastservice.DeleteForecastExportJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteForecastExportJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DeleteForecastExportJobOutput)
	return
}

func (d *ForecastServiceDouble) DeleteForecastExportJobWithContext(i0 context.Context, i1 *forecastservice.DeleteForecastExportJobInput, i2 ...request.Option) (r0 *forecastservice.DeleteForecastExportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteForecastExportJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DeleteForecastExportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDeleteForecastExportJobWithContext(ctx context.Context, in *forecastservice.DeleteForecastExportJobInput, _ ...request.Option) (*forecastservice.DeleteForecastExportJobOutput, error) {

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

func (d *ForecastServiceDouble) DeleteForecastRequest(i0 *forecastservice.DeleteForecastInput) (r0 *request.Request, r1 *forecastservice.DeleteForecastOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteForecastRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DeleteForecastOutput)
	return
}

func (d *ForecastServiceDouble) DeleteForecastWithContext(i0 context.Context, i1 *forecastservice.DeleteForecastInput, i2 ...request.Option) (r0 *forecastservice.DeleteForecastOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteForecastWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DeleteForecastOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDeleteForecastWithContext(ctx context.Context, in *forecastservice.DeleteForecastInput, _ ...request.Option) (*forecastservice.DeleteForecastOutput, error) {

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

func (d *ForecastServiceDouble) DeletePredictor(i0 *forecastservice.DeletePredictorInput) (r0 *forecastservice.DeletePredictorOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeletePredictor", i0)
	r0, _ = returns[0].(*forecastservice.DeletePredictorOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DeletePredictorRequest(i0 *forecastservice.DeletePredictorInput) (r0 *request.Request, r1 *forecastservice.DeletePredictorOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeletePredictorRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DeletePredictorOutput)
	return
}

func (d *ForecastServiceDouble) DeletePredictorWithContext(i0 context.Context, i1 *forecastservice.DeletePredictorInput, i2 ...request.Option) (r0 *forecastservice.DeletePredictorOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeletePredictorWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DeletePredictorOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDeletePredictorWithContext(ctx context.Context, in *forecastservice.DeletePredictorInput, _ ...request.Option) (*forecastservice.DeletePredictorOutput, error) {

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

func (d *ForecastServiceDouble) DescribeDataset(i0 *forecastservice.DescribeDatasetInput) (r0 *forecastservice.DescribeDatasetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDataset", i0)
	r0, _ = returns[0].(*forecastservice.DescribeDatasetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DescribeDatasetGroup(i0 *forecastservice.DescribeDatasetGroupInput) (r0 *forecastservice.DescribeDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetGroup", i0)
	r0, _ = returns[0].(*forecastservice.DescribeDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DescribeDatasetGroupRequest(i0 *forecastservice.DescribeDatasetGroupInput) (r0 *request.Request, r1 *forecastservice.DescribeDatasetGroupOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetGroupRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DescribeDatasetGroupOutput)
	return
}

func (d *ForecastServiceDouble) DescribeDatasetGroupWithContext(i0 context.Context, i1 *forecastservice.DescribeDatasetGroupInput, i2 ...request.Option) (r0 *forecastservice.DescribeDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetGroupWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DescribeDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDescribeDatasetGroupWithContext(ctx context.Context, in *forecastservice.DescribeDatasetGroupInput, _ ...request.Option) (*forecastservice.DescribeDatasetGroupOutput, error) {

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

func (d *ForecastServiceDouble) DescribeDatasetImportJob(i0 *forecastservice.DescribeDatasetImportJobInput) (r0 *forecastservice.DescribeDatasetImportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetImportJob", i0)
	r0, _ = returns[0].(*forecastservice.DescribeDatasetImportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DescribeDatasetImportJobRequest(i0 *forecastservice.DescribeDatasetImportJobInput) (r0 *request.Request, r1 *forecastservice.DescribeDatasetImportJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetImportJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DescribeDatasetImportJobOutput)
	return
}

func (d *ForecastServiceDouble) DescribeDatasetImportJobWithContext(i0 context.Context, i1 *forecastservice.DescribeDatasetImportJobInput, i2 ...request.Option) (r0 *forecastservice.DescribeDatasetImportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetImportJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DescribeDatasetImportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDescribeDatasetImportJobWithContext(ctx context.Context, in *forecastservice.DescribeDatasetImportJobInput, _ ...request.Option) (*forecastservice.DescribeDatasetImportJobOutput, error) {

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

func (d *ForecastServiceDouble) DescribeDatasetRequest(i0 *forecastservice.DescribeDatasetInput) (r0 *request.Request, r1 *forecastservice.DescribeDatasetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DescribeDatasetOutput)
	return
}

func (d *ForecastServiceDouble) DescribeDatasetWithContext(i0 context.Context, i1 *forecastservice.DescribeDatasetInput, i2 ...request.Option) (r0 *forecastservice.DescribeDatasetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDatasetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DescribeDatasetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDescribeDatasetWithContext(ctx context.Context, in *forecastservice.DescribeDatasetInput, _ ...request.Option) (*forecastservice.DescribeDatasetOutput, error) {

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

func (d *ForecastServiceDouble) DescribeForecast(i0 *forecastservice.DescribeForecastInput) (r0 *forecastservice.DescribeForecastOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeForecast", i0)
	r0, _ = returns[0].(*forecastservice.DescribeForecastOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DescribeForecastExportJob(i0 *forecastservice.DescribeForecastExportJobInput) (r0 *forecastservice.DescribeForecastExportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeForecastExportJob", i0)
	r0, _ = returns[0].(*forecastservice.DescribeForecastExportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DescribeForecastExportJobRequest(i0 *forecastservice.DescribeForecastExportJobInput) (r0 *request.Request, r1 *forecastservice.DescribeForecastExportJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeForecastExportJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DescribeForecastExportJobOutput)
	return
}

func (d *ForecastServiceDouble) DescribeForecastExportJobWithContext(i0 context.Context, i1 *forecastservice.DescribeForecastExportJobInput, i2 ...request.Option) (r0 *forecastservice.DescribeForecastExportJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeForecastExportJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DescribeForecastExportJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDescribeForecastExportJobWithContext(ctx context.Context, in *forecastservice.DescribeForecastExportJobInput, _ ...request.Option) (*forecastservice.DescribeForecastExportJobOutput, error) {

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

func (d *ForecastServiceDouble) DescribeForecastRequest(i0 *forecastservice.DescribeForecastInput) (r0 *request.Request, r1 *forecastservice.DescribeForecastOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeForecastRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DescribeForecastOutput)
	return
}

func (d *ForecastServiceDouble) DescribeForecastWithContext(i0 context.Context, i1 *forecastservice.DescribeForecastInput, i2 ...request.Option) (r0 *forecastservice.DescribeForecastOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeForecastWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DescribeForecastOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDescribeForecastWithContext(ctx context.Context, in *forecastservice.DescribeForecastInput, _ ...request.Option) (*forecastservice.DescribeForecastOutput, error) {

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

func (d *ForecastServiceDouble) DescribePredictor(i0 *forecastservice.DescribePredictorInput) (r0 *forecastservice.DescribePredictorOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribePredictor", i0)
	r0, _ = returns[0].(*forecastservice.DescribePredictorOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) DescribePredictorRequest(i0 *forecastservice.DescribePredictorInput) (r0 *request.Request, r1 *forecastservice.DescribePredictorOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribePredictorRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.DescribePredictorOutput)
	return
}

func (d *ForecastServiceDouble) DescribePredictorWithContext(i0 context.Context, i1 *forecastservice.DescribePredictorInput, i2 ...request.Option) (r0 *forecastservice.DescribePredictorOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribePredictorWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.DescribePredictorOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeDescribePredictorWithContext(ctx context.Context, in *forecastservice.DescribePredictorInput, _ ...request.Option) (*forecastservice.DescribePredictorOutput, error) {

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

func (d *ForecastServiceDouble) GetAccuracyMetrics(i0 *forecastservice.GetAccuracyMetricsInput) (r0 *forecastservice.GetAccuracyMetricsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAccuracyMetrics", i0)
	r0, _ = returns[0].(*forecastservice.GetAccuracyMetricsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) GetAccuracyMetricsRequest(i0 *forecastservice.GetAccuracyMetricsInput) (r0 *request.Request, r1 *forecastservice.GetAccuracyMetricsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAccuracyMetricsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.GetAccuracyMetricsOutput)
	return
}

func (d *ForecastServiceDouble) GetAccuracyMetricsWithContext(i0 context.Context, i1 *forecastservice.GetAccuracyMetricsInput, i2 ...request.Option) (r0 *forecastservice.GetAccuracyMetricsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAccuracyMetricsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.GetAccuracyMetricsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeGetAccuracyMetricsWithContext(ctx context.Context, in *forecastservice.GetAccuracyMetricsInput, _ ...request.Option) (*forecastservice.GetAccuracyMetricsOutput, error) {

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

func (d *ForecastServiceDouble) ListDatasetGroups(i0 *forecastservice.ListDatasetGroupsInput) (r0 *forecastservice.ListDatasetGroupsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetGroups", i0)
	r0, _ = returns[0].(*forecastservice.ListDatasetGroupsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) ListDatasetGroupsPages(i0 *forecastservice.ListDatasetGroupsInput, i1 func(*forecastservice.ListDatasetGroupsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetGroupsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetGroupsPages(in *forecastservice.ListDatasetGroupsInput, pager func(*forecastservice.ListDatasetGroupsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListDatasetGroups", paginators, in, pager)
}

func (d *ForecastServiceDouble) ListDatasetGroupsPagesWithContext(i0 context.Context, i1 *forecastservice.ListDatasetGroupsInput, i2 func(*forecastservice.ListDatasetGroupsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetGroupsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetGroupsPagesWithContext(ctx context.Context, in *forecastservice.ListDatasetGroupsInput, pager func(*forecastservice.ListDatasetGroupsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListDatasetGroups", paginators, ctx, in, pager, options...)
}

func (d *ForecastServiceDouble) ListDatasetGroupsRequest(i0 *forecastservice.ListDatasetGroupsInput) (r0 *request.Request, r1 *forecastservice.ListDatasetGroupsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetGroupsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.ListDatasetGroupsOutput)
	return
}

func (d *ForecastServiceDouble) ListDatasetGroupsWithContext(i0 context.Context, i1 *forecastservice.ListDatasetGroupsInput, i2 ...request.Option) (r0 *forecastservice.ListDatasetGroupsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetGroupsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.ListDatasetGroupsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetGroupsWithContext(ctx context.Context, in *forecastservice.ListDatasetGroupsInput, _ ...request.Option) (*forecastservice.ListDatasetGroupsOutput, error) {

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

func (d *ForecastServiceDouble) ListDatasetImportJobs(i0 *forecastservice.ListDatasetImportJobsInput) (r0 *forecastservice.ListDatasetImportJobsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetImportJobs", i0)
	r0, _ = returns[0].(*forecastservice.ListDatasetImportJobsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) ListDatasetImportJobsPages(i0 *forecastservice.ListDatasetImportJobsInput, i1 func(*forecastservice.ListDatasetImportJobsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetImportJobsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetImportJobsPages(in *forecastservice.ListDatasetImportJobsInput, pager func(*forecastservice.ListDatasetImportJobsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListDatasetImportJobs", paginators, in, pager)
}

func (d *ForecastServiceDouble) ListDatasetImportJobsPagesWithContext(i0 context.Context, i1 *forecastservice.ListDatasetImportJobsInput, i2 func(*forecastservice.ListDatasetImportJobsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetImportJobsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetImportJobsPagesWithContext(ctx context.Context, in *forecastservice.ListDatasetImportJobsInput, pager func(*forecastservice.ListDatasetImportJobsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListDatasetImportJobs", paginators, ctx, in, pager, options...)
}

func (d *ForecastServiceDouble) ListDatasetImportJobsRequest(i0 *forecastservice.ListDatasetImportJobsInput) (r0 *request.Request, r1 *forecastservice.ListDatasetImportJobsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetImportJobsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.ListDatasetImportJobsOutput)
	return
}

func (d *ForecastServiceDouble) ListDatasetImportJobsWithContext(i0 context.Context, i1 *forecastservice.ListDatasetImportJobsInput, i2 ...request.Option) (r0 *forecastservice.ListDatasetImportJobsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetImportJobsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.ListDatasetImportJobsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetImportJobsWithContext(ctx context.Context, in *forecastservice.ListDatasetImportJobsInput, _ ...request.Option) (*forecastservice.ListDatasetImportJobsOutput, error) {

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

func (d *ForecastServiceDouble) ListDatasets(i0 *forecastservice.ListDatasetsInput) (r0 *forecastservice.ListDatasetsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasets", i0)
	r0, _ = returns[0].(*forecastservice.ListDatasetsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) ListDatasetsPages(i0 *forecastservice.ListDatasetsInput, i1 func(*forecastservice.ListDatasetsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetsPages(in *forecastservice.ListDatasetsInput, pager func(*forecastservice.ListDatasetsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListDatasets", paginators, in, pager)
}

func (d *ForecastServiceDouble) ListDatasetsPagesWithContext(i0 context.Context, i1 *forecastservice.ListDatasetsInput, i2 func(*forecastservice.ListDatasetsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetsPagesWithContext(ctx context.Context, in *forecastservice.ListDatasetsInput, pager func(*forecastservice.ListDatasetsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListDatasets", paginators, ctx, in, pager, options...)
}

func (d *ForecastServiceDouble) ListDatasetsRequest(i0 *forecastservice.ListDatasetsInput) (r0 *request.Request, r1 *forecastservice.ListDatasetsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.ListDatasetsOutput)
	return
}

func (d *ForecastServiceDouble) ListDatasetsWithContext(i0 context.Context, i1 *forecastservice.ListDatasetsInput, i2 ...request.Option) (r0 *forecastservice.ListDatasetsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDatasetsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.ListDatasetsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeListDatasetsWithContext(ctx context.Context, in *forecastservice.ListDatasetsInput, _ ...request.Option) (*forecastservice.ListDatasetsOutput, error) {

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

func (d *ForecastServiceDouble) ListForecastExportJobs(i0 *forecastservice.ListForecastExportJobsInput) (r0 *forecastservice.ListForecastExportJobsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastExportJobs", i0)
	r0, _ = returns[0].(*forecastservice.ListForecastExportJobsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) ListForecastExportJobsPages(i0 *forecastservice.ListForecastExportJobsInput, i1 func(*forecastservice.ListForecastExportJobsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastExportJobsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListForecastExportJobsPages(in *forecastservice.ListForecastExportJobsInput, pager func(*forecastservice.ListForecastExportJobsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListForecastExportJobs", paginators, in, pager)
}

func (d *ForecastServiceDouble) ListForecastExportJobsPagesWithContext(i0 context.Context, i1 *forecastservice.ListForecastExportJobsInput, i2 func(*forecastservice.ListForecastExportJobsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastExportJobsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListForecastExportJobsPagesWithContext(ctx context.Context, in *forecastservice.ListForecastExportJobsInput, pager func(*forecastservice.ListForecastExportJobsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListForecastExportJobs", paginators, ctx, in, pager, options...)
}

func (d *ForecastServiceDouble) ListForecastExportJobsRequest(i0 *forecastservice.ListForecastExportJobsInput) (r0 *request.Request, r1 *forecastservice.ListForecastExportJobsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastExportJobsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.ListForecastExportJobsOutput)
	return
}

func (d *ForecastServiceDouble) ListForecastExportJobsWithContext(i0 context.Context, i1 *forecastservice.ListForecastExportJobsInput, i2 ...request.Option) (r0 *forecastservice.ListForecastExportJobsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastExportJobsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.ListForecastExportJobsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeListForecastExportJobsWithContext(ctx context.Context, in *forecastservice.ListForecastExportJobsInput, _ ...request.Option) (*forecastservice.ListForecastExportJobsOutput, error) {

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

func (d *ForecastServiceDouble) ListForecasts(i0 *forecastservice.ListForecastsInput) (r0 *forecastservice.ListForecastsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecasts", i0)
	r0, _ = returns[0].(*forecastservice.ListForecastsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) ListForecastsPages(i0 *forecastservice.ListForecastsInput, i1 func(*forecastservice.ListForecastsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListForecastsPages(in *forecastservice.ListForecastsInput, pager func(*forecastservice.ListForecastsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListForecasts", paginators, in, pager)
}

func (d *ForecastServiceDouble) ListForecastsPagesWithContext(i0 context.Context, i1 *forecastservice.ListForecastsInput, i2 func(*forecastservice.ListForecastsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListForecastsPagesWithContext(ctx context.Context, in *forecastservice.ListForecastsInput, pager func(*forecastservice.ListForecastsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListForecasts", paginators, ctx, in, pager, options...)
}

func (d *ForecastServiceDouble) ListForecastsRequest(i0 *forecastservice.ListForecastsInput) (r0 *request.Request, r1 *forecastservice.ListForecastsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.ListForecastsOutput)
	return
}

func (d *ForecastServiceDouble) ListForecastsWithContext(i0 context.Context, i1 *forecastservice.ListForecastsInput, i2 ...request.Option) (r0 *forecastservice.ListForecastsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListForecastsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.ListForecastsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeListForecastsWithContext(ctx context.Context, in *forecastservice.ListForecastsInput, _ ...request.Option) (*forecastservice.ListForecastsOutput, error) {

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

func (d *ForecastServiceDouble) ListPredictors(i0 *forecastservice.ListPredictorsInput) (r0 *forecastservice.ListPredictorsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListPredictors", i0)
	r0, _ = returns[0].(*forecastservice.ListPredictorsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) ListPredictorsPages(i0 *forecastservice.ListPredictorsInput, i1 func(*forecastservice.ListPredictorsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListPredictorsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListPredictorsPages(in *forecastservice.ListPredictorsInput, pager func(*forecastservice.ListPredictorsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListPredictors", paginators, in, pager)
}

func (d *ForecastServiceDouble) ListPredictorsPagesWithContext(i0 context.Context, i1 *forecastservice.ListPredictorsInput, i2 func(*forecastservice.ListPredictorsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListPredictorsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *ForecastServiceDouble) fakeListPredictorsPagesWithContext(ctx context.Context, in *forecastservice.ListPredictorsInput, pager func(*forecastservice.ListPredictorsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListPredictors", paginators, ctx, in, pager, options...)
}

func (d *ForecastServiceDouble) ListPredictorsRequest(i0 *forecastservice.ListPredictorsInput) (r0 *request.Request, r1 *forecastservice.ListPredictorsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListPredictorsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.ListPredictorsOutput)
	return
}

func (d *ForecastServiceDouble) ListPredictorsWithContext(i0 context.Context, i1 *forecastservice.ListPredictorsInput, i2 ...request.Option) (r0 *forecastservice.ListPredictorsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListPredictorsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.ListPredictorsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeListPredictorsWithContext(ctx context.Context, in *forecastservice.ListPredictorsInput, _ ...request.Option) (*forecastservice.ListPredictorsOutput, error) {

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

func (d *ForecastServiceDouble) UpdateDatasetGroup(i0 *forecastservice.UpdateDatasetGroupInput) (r0 *forecastservice.UpdateDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDatasetGroup", i0)
	r0, _ = returns[0].(*forecastservice.UpdateDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) UpdateDatasetGroupRequest(i0 *forecastservice.UpdateDatasetGroupInput) (r0 *request.Request, r1 *forecastservice.UpdateDatasetGroupOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDatasetGroupRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*forecastservice.UpdateDatasetGroupOutput)
	return
}

func (d *ForecastServiceDouble) UpdateDatasetGroupWithContext(i0 context.Context, i1 *forecastservice.UpdateDatasetGroupInput, i2 ...request.Option) (r0 *forecastservice.UpdateDatasetGroupOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDatasetGroupWithContext", i0, i1, i2)
	r0, _ = returns[0].(*forecastservice.UpdateDatasetGroupOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ForecastServiceDouble) fakeUpdateDatasetGroupWithContext(ctx context.Context, in *forecastservice.UpdateDatasetGroupInput, _ ...request.Option) (*forecastservice.UpdateDatasetGroupOutput, error) {

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