// Code generated by MockGen. DO NOT EDIT.
// Source: /home/runner/go/pkg/mod/github.com/aws/aws-sdk-go@v1.55.5/service/quicksight/quicksightiface/interface.go

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

import (
	reflect "reflect"

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

// MockQuickSightAPI is a mock of QuickSightAPI interface.
type MockQuickSightAPI struct {
	ctrl     *gomock.Controller
	recorder *MockQuickSightAPIMockRecorder
}

// MockQuickSightAPIMockRecorder is the mock recorder for MockQuickSightAPI.
type MockQuickSightAPIMockRecorder struct {
	mock *MockQuickSightAPI
}

// NewMockQuickSightAPI creates a new mock instance.
func NewMockQuickSightAPI(ctrl *gomock.Controller) *MockQuickSightAPI {
	mock := &MockQuickSightAPI{ctrl: ctrl}
	mock.recorder = &MockQuickSightAPIMockRecorder{mock}
	return mock
}

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

// BatchCreateTopicReviewedAnswer mocks base method.
func (m *MockQuickSightAPI) BatchCreateTopicReviewedAnswer(arg0 *quicksight.BatchCreateTopicReviewedAnswerInput) (*quicksight.BatchCreateTopicReviewedAnswerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateTopicReviewedAnswer", arg0)
	ret0, _ := ret[0].(*quicksight.BatchCreateTopicReviewedAnswerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchCreateTopicReviewedAnswerRequest mocks base method.
func (m *MockQuickSightAPI) BatchCreateTopicReviewedAnswerRequest(arg0 *quicksight.BatchCreateTopicReviewedAnswerInput) (*request.Request, *quicksight.BatchCreateTopicReviewedAnswerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateTopicReviewedAnswerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.BatchCreateTopicReviewedAnswerOutput)
	return ret0, ret1
}

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

// BatchCreateTopicReviewedAnswerWithContext mocks base method.
func (m *MockQuickSightAPI) BatchCreateTopicReviewedAnswerWithContext(arg0 aws.Context, arg1 *quicksight.BatchCreateTopicReviewedAnswerInput, arg2 ...request.Option) (*quicksight.BatchCreateTopicReviewedAnswerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchCreateTopicReviewedAnswerWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.BatchCreateTopicReviewedAnswerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchDeleteTopicReviewedAnswer mocks base method.
func (m *MockQuickSightAPI) BatchDeleteTopicReviewedAnswer(arg0 *quicksight.BatchDeleteTopicReviewedAnswerInput) (*quicksight.BatchDeleteTopicReviewedAnswerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDeleteTopicReviewedAnswer", arg0)
	ret0, _ := ret[0].(*quicksight.BatchDeleteTopicReviewedAnswerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchDeleteTopicReviewedAnswerRequest mocks base method.
func (m *MockQuickSightAPI) BatchDeleteTopicReviewedAnswerRequest(arg0 *quicksight.BatchDeleteTopicReviewedAnswerInput) (*request.Request, *quicksight.BatchDeleteTopicReviewedAnswerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDeleteTopicReviewedAnswerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.BatchDeleteTopicReviewedAnswerOutput)
	return ret0, ret1
}

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

// BatchDeleteTopicReviewedAnswerWithContext mocks base method.
func (m *MockQuickSightAPI) BatchDeleteTopicReviewedAnswerWithContext(arg0 aws.Context, arg1 *quicksight.BatchDeleteTopicReviewedAnswerInput, arg2 ...request.Option) (*quicksight.BatchDeleteTopicReviewedAnswerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchDeleteTopicReviewedAnswerWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.BatchDeleteTopicReviewedAnswerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelIngestion mocks base method.
func (m *MockQuickSightAPI) CancelIngestion(arg0 *quicksight.CancelIngestionInput) (*quicksight.CancelIngestionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelIngestion", arg0)
	ret0, _ := ret[0].(*quicksight.CancelIngestionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelIngestionRequest mocks base method.
func (m *MockQuickSightAPI) CancelIngestionRequest(arg0 *quicksight.CancelIngestionInput) (*request.Request, *quicksight.CancelIngestionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelIngestionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CancelIngestionOutput)
	return ret0, ret1
}

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

// CancelIngestionWithContext mocks base method.
func (m *MockQuickSightAPI) CancelIngestionWithContext(arg0 aws.Context, arg1 *quicksight.CancelIngestionInput, arg2 ...request.Option) (*quicksight.CancelIngestionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelIngestionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CancelIngestionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAccountCustomization mocks base method.
func (m *MockQuickSightAPI) CreateAccountCustomization(arg0 *quicksight.CreateAccountCustomizationInput) (*quicksight.CreateAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountCustomization", arg0)
	ret0, _ := ret[0].(*quicksight.CreateAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAccountCustomizationRequest mocks base method.
func (m *MockQuickSightAPI) CreateAccountCustomizationRequest(arg0 *quicksight.CreateAccountCustomizationInput) (*request.Request, *quicksight.CreateAccountCustomizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountCustomizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateAccountCustomizationOutput)
	return ret0, ret1
}

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

// CreateAccountCustomizationWithContext mocks base method.
func (m *MockQuickSightAPI) CreateAccountCustomizationWithContext(arg0 aws.Context, arg1 *quicksight.CreateAccountCustomizationInput, arg2 ...request.Option) (*quicksight.CreateAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAccountCustomizationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAccountSubscription mocks base method.
func (m *MockQuickSightAPI) CreateAccountSubscription(arg0 *quicksight.CreateAccountSubscriptionInput) (*quicksight.CreateAccountSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountSubscription", arg0)
	ret0, _ := ret[0].(*quicksight.CreateAccountSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAccountSubscriptionRequest mocks base method.
func (m *MockQuickSightAPI) CreateAccountSubscriptionRequest(arg0 *quicksight.CreateAccountSubscriptionInput) (*request.Request, *quicksight.CreateAccountSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateAccountSubscriptionOutput)
	return ret0, ret1
}

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

// CreateAccountSubscriptionWithContext mocks base method.
func (m *MockQuickSightAPI) CreateAccountSubscriptionWithContext(arg0 aws.Context, arg1 *quicksight.CreateAccountSubscriptionInput, arg2 ...request.Option) (*quicksight.CreateAccountSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAccountSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateAccountSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAnalysis mocks base method.
func (m *MockQuickSightAPI) CreateAnalysis(arg0 *quicksight.CreateAnalysisInput) (*quicksight.CreateAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAnalysis", arg0)
	ret0, _ := ret[0].(*quicksight.CreateAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAnalysisRequest mocks base method.
func (m *MockQuickSightAPI) CreateAnalysisRequest(arg0 *quicksight.CreateAnalysisInput) (*request.Request, *quicksight.CreateAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateAnalysisOutput)
	return ret0, ret1
}

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

// CreateAnalysisWithContext mocks base method.
func (m *MockQuickSightAPI) CreateAnalysisWithContext(arg0 aws.Context, arg1 *quicksight.CreateAnalysisInput, arg2 ...request.Option) (*quicksight.CreateAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDashboard mocks base method.
func (m *MockQuickSightAPI) CreateDashboard(arg0 *quicksight.CreateDashboardInput) (*quicksight.CreateDashboardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDashboard", arg0)
	ret0, _ := ret[0].(*quicksight.CreateDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDashboardRequest mocks base method.
func (m *MockQuickSightAPI) CreateDashboardRequest(arg0 *quicksight.CreateDashboardInput) (*request.Request, *quicksight.CreateDashboardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDashboardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateDashboardOutput)
	return ret0, ret1
}

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

// CreateDashboardWithContext mocks base method.
func (m *MockQuickSightAPI) CreateDashboardWithContext(arg0 aws.Context, arg1 *quicksight.CreateDashboardInput, arg2 ...request.Option) (*quicksight.CreateDashboardOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDashboardWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDataSet mocks base method.
func (m *MockQuickSightAPI) CreateDataSet(arg0 *quicksight.CreateDataSetInput) (*quicksight.CreateDataSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataSet", arg0)
	ret0, _ := ret[0].(*quicksight.CreateDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDataSetRequest mocks base method.
func (m *MockQuickSightAPI) CreateDataSetRequest(arg0 *quicksight.CreateDataSetInput) (*request.Request, *quicksight.CreateDataSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateDataSetOutput)
	return ret0, ret1
}

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

// CreateDataSetWithContext mocks base method.
func (m *MockQuickSightAPI) CreateDataSetWithContext(arg0 aws.Context, arg1 *quicksight.CreateDataSetInput, arg2 ...request.Option) (*quicksight.CreateDataSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDataSetWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDataSource mocks base method.
func (m *MockQuickSightAPI) CreateDataSource(arg0 *quicksight.CreateDataSourceInput) (*quicksight.CreateDataSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataSource", arg0)
	ret0, _ := ret[0].(*quicksight.CreateDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDataSourceRequest mocks base method.
func (m *MockQuickSightAPI) CreateDataSourceRequest(arg0 *quicksight.CreateDataSourceInput) (*request.Request, *quicksight.CreateDataSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateDataSourceOutput)
	return ret0, ret1
}

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

// CreateDataSourceWithContext mocks base method.
func (m *MockQuickSightAPI) CreateDataSourceWithContext(arg0 aws.Context, arg1 *quicksight.CreateDataSourceInput, arg2 ...request.Option) (*quicksight.CreateDataSourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDataSourceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFolder mocks base method.
func (m *MockQuickSightAPI) CreateFolder(arg0 *quicksight.CreateFolderInput) (*quicksight.CreateFolderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFolder", arg0)
	ret0, _ := ret[0].(*quicksight.CreateFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFolderMembership mocks base method.
func (m *MockQuickSightAPI) CreateFolderMembership(arg0 *quicksight.CreateFolderMembershipInput) (*quicksight.CreateFolderMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFolderMembership", arg0)
	ret0, _ := ret[0].(*quicksight.CreateFolderMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFolderMembershipRequest mocks base method.
func (m *MockQuickSightAPI) CreateFolderMembershipRequest(arg0 *quicksight.CreateFolderMembershipInput) (*request.Request, *quicksight.CreateFolderMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFolderMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateFolderMembershipOutput)
	return ret0, ret1
}

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

// CreateFolderMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) CreateFolderMembershipWithContext(arg0 aws.Context, arg1 *quicksight.CreateFolderMembershipInput, arg2 ...request.Option) (*quicksight.CreateFolderMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFolderMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateFolderMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFolderRequest mocks base method.
func (m *MockQuickSightAPI) CreateFolderRequest(arg0 *quicksight.CreateFolderInput) (*request.Request, *quicksight.CreateFolderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFolderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateFolderOutput)
	return ret0, ret1
}

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

// CreateFolderWithContext mocks base method.
func (m *MockQuickSightAPI) CreateFolderWithContext(arg0 aws.Context, arg1 *quicksight.CreateFolderInput, arg2 ...request.Option) (*quicksight.CreateFolderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFolderWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGroup mocks base method.
func (m *MockQuickSightAPI) CreateGroup(arg0 *quicksight.CreateGroupInput) (*quicksight.CreateGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroup", arg0)
	ret0, _ := ret[0].(*quicksight.CreateGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGroupMembership mocks base method.
func (m *MockQuickSightAPI) CreateGroupMembership(arg0 *quicksight.CreateGroupMembershipInput) (*quicksight.CreateGroupMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroupMembership", arg0)
	ret0, _ := ret[0].(*quicksight.CreateGroupMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGroupMembershipRequest mocks base method.
func (m *MockQuickSightAPI) CreateGroupMembershipRequest(arg0 *quicksight.CreateGroupMembershipInput) (*request.Request, *quicksight.CreateGroupMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroupMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateGroupMembershipOutput)
	return ret0, ret1
}

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

// CreateGroupMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) CreateGroupMembershipWithContext(arg0 aws.Context, arg1 *quicksight.CreateGroupMembershipInput, arg2 ...request.Option) (*quicksight.CreateGroupMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGroupMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateGroupMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGroupRequest mocks base method.
func (m *MockQuickSightAPI) CreateGroupRequest(arg0 *quicksight.CreateGroupInput) (*request.Request, *quicksight.CreateGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateGroupOutput)
	return ret0, ret1
}

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

// CreateGroupWithContext mocks base method.
func (m *MockQuickSightAPI) CreateGroupWithContext(arg0 aws.Context, arg1 *quicksight.CreateGroupInput, arg2 ...request.Option) (*quicksight.CreateGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGroupWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIAMPolicyAssignment mocks base method.
func (m *MockQuickSightAPI) CreateIAMPolicyAssignment(arg0 *quicksight.CreateIAMPolicyAssignmentInput) (*quicksight.CreateIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIAMPolicyAssignment", arg0)
	ret0, _ := ret[0].(*quicksight.CreateIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIAMPolicyAssignmentRequest mocks base method.
func (m *MockQuickSightAPI) CreateIAMPolicyAssignmentRequest(arg0 *quicksight.CreateIAMPolicyAssignmentInput) (*request.Request, *quicksight.CreateIAMPolicyAssignmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIAMPolicyAssignmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateIAMPolicyAssignmentOutput)
	return ret0, ret1
}

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

// CreateIAMPolicyAssignmentWithContext mocks base method.
func (m *MockQuickSightAPI) CreateIAMPolicyAssignmentWithContext(arg0 aws.Context, arg1 *quicksight.CreateIAMPolicyAssignmentInput, arg2 ...request.Option) (*quicksight.CreateIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIAMPolicyAssignmentWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIngestion mocks base method.
func (m *MockQuickSightAPI) CreateIngestion(arg0 *quicksight.CreateIngestionInput) (*quicksight.CreateIngestionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIngestion", arg0)
	ret0, _ := ret[0].(*quicksight.CreateIngestionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIngestionRequest mocks base method.
func (m *MockQuickSightAPI) CreateIngestionRequest(arg0 *quicksight.CreateIngestionInput) (*request.Request, *quicksight.CreateIngestionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIngestionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateIngestionOutput)
	return ret0, ret1
}

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

// CreateIngestionWithContext mocks base method.
func (m *MockQuickSightAPI) CreateIngestionWithContext(arg0 aws.Context, arg1 *quicksight.CreateIngestionInput, arg2 ...request.Option) (*quicksight.CreateIngestionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIngestionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateIngestionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNamespace mocks base method.
func (m *MockQuickSightAPI) CreateNamespace(arg0 *quicksight.CreateNamespaceInput) (*quicksight.CreateNamespaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", arg0)
	ret0, _ := ret[0].(*quicksight.CreateNamespaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNamespaceRequest mocks base method.
func (m *MockQuickSightAPI) CreateNamespaceRequest(arg0 *quicksight.CreateNamespaceInput) (*request.Request, *quicksight.CreateNamespaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateNamespaceOutput)
	return ret0, ret1
}

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

// CreateNamespaceWithContext mocks base method.
func (m *MockQuickSightAPI) CreateNamespaceWithContext(arg0 aws.Context, arg1 *quicksight.CreateNamespaceInput, arg2 ...request.Option) (*quicksight.CreateNamespaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNamespaceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateNamespaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) CreateRefreshSchedule(arg0 *quicksight.CreateRefreshScheduleInput) (*quicksight.CreateRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.CreateRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) CreateRefreshScheduleRequest(arg0 *quicksight.CreateRefreshScheduleInput) (*request.Request, *quicksight.CreateRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateRefreshScheduleOutput)
	return ret0, ret1
}

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

// CreateRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) CreateRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.CreateRefreshScheduleInput, arg2 ...request.Option) (*quicksight.CreateRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRoleMembership mocks base method.
func (m *MockQuickSightAPI) CreateRoleMembership(arg0 *quicksight.CreateRoleMembershipInput) (*quicksight.CreateRoleMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoleMembership", arg0)
	ret0, _ := ret[0].(*quicksight.CreateRoleMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRoleMembershipRequest mocks base method.
func (m *MockQuickSightAPI) CreateRoleMembershipRequest(arg0 *quicksight.CreateRoleMembershipInput) (*request.Request, *quicksight.CreateRoleMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoleMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateRoleMembershipOutput)
	return ret0, ret1
}

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

// CreateRoleMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) CreateRoleMembershipWithContext(arg0 aws.Context, arg1 *quicksight.CreateRoleMembershipInput, arg2 ...request.Option) (*quicksight.CreateRoleMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRoleMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateRoleMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTemplate mocks base method.
func (m *MockQuickSightAPI) CreateTemplate(arg0 *quicksight.CreateTemplateInput) (*quicksight.CreateTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTemplate", arg0)
	ret0, _ := ret[0].(*quicksight.CreateTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTemplateAlias mocks base method.
func (m *MockQuickSightAPI) CreateTemplateAlias(arg0 *quicksight.CreateTemplateAliasInput) (*quicksight.CreateTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTemplateAlias", arg0)
	ret0, _ := ret[0].(*quicksight.CreateTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTemplateAliasRequest mocks base method.
func (m *MockQuickSightAPI) CreateTemplateAliasRequest(arg0 *quicksight.CreateTemplateAliasInput) (*request.Request, *quicksight.CreateTemplateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTemplateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateTemplateAliasOutput)
	return ret0, ret1
}

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

// CreateTemplateAliasWithContext mocks base method.
func (m *MockQuickSightAPI) CreateTemplateAliasWithContext(arg0 aws.Context, arg1 *quicksight.CreateTemplateAliasInput, arg2 ...request.Option) (*quicksight.CreateTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTemplateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTemplateRequest mocks base method.
func (m *MockQuickSightAPI) CreateTemplateRequest(arg0 *quicksight.CreateTemplateInput) (*request.Request, *quicksight.CreateTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateTemplateOutput)
	return ret0, ret1
}

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

// CreateTemplateWithContext mocks base method.
func (m *MockQuickSightAPI) CreateTemplateWithContext(arg0 aws.Context, arg1 *quicksight.CreateTemplateInput, arg2 ...request.Option) (*quicksight.CreateTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTheme mocks base method.
func (m *MockQuickSightAPI) CreateTheme(arg0 *quicksight.CreateThemeInput) (*quicksight.CreateThemeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTheme", arg0)
	ret0, _ := ret[0].(*quicksight.CreateThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateThemeAlias mocks base method.
func (m *MockQuickSightAPI) CreateThemeAlias(arg0 *quicksight.CreateThemeAliasInput) (*quicksight.CreateThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateThemeAlias", arg0)
	ret0, _ := ret[0].(*quicksight.CreateThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateThemeAliasRequest mocks base method.
func (m *MockQuickSightAPI) CreateThemeAliasRequest(arg0 *quicksight.CreateThemeAliasInput) (*request.Request, *quicksight.CreateThemeAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateThemeAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateThemeAliasOutput)
	return ret0, ret1
}

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

// CreateThemeAliasWithContext mocks base method.
func (m *MockQuickSightAPI) CreateThemeAliasWithContext(arg0 aws.Context, arg1 *quicksight.CreateThemeAliasInput, arg2 ...request.Option) (*quicksight.CreateThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateThemeAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateThemeRequest mocks base method.
func (m *MockQuickSightAPI) CreateThemeRequest(arg0 *quicksight.CreateThemeInput) (*request.Request, *quicksight.CreateThemeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateThemeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateThemeOutput)
	return ret0, ret1
}

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

// CreateThemeWithContext mocks base method.
func (m *MockQuickSightAPI) CreateThemeWithContext(arg0 aws.Context, arg1 *quicksight.CreateThemeInput, arg2 ...request.Option) (*quicksight.CreateThemeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateThemeWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTopic mocks base method.
func (m *MockQuickSightAPI) CreateTopic(arg0 *quicksight.CreateTopicInput) (*quicksight.CreateTopicOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTopic", arg0)
	ret0, _ := ret[0].(*quicksight.CreateTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTopicRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) CreateTopicRefreshSchedule(arg0 *quicksight.CreateTopicRefreshScheduleInput) (*quicksight.CreateTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTopicRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.CreateTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTopicRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) CreateTopicRefreshScheduleRequest(arg0 *quicksight.CreateTopicRefreshScheduleInput) (*request.Request, *quicksight.CreateTopicRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTopicRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateTopicRefreshScheduleOutput)
	return ret0, ret1
}

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

// CreateTopicRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) CreateTopicRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.CreateTopicRefreshScheduleInput, arg2 ...request.Option) (*quicksight.CreateTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTopicRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTopicRequest mocks base method.
func (m *MockQuickSightAPI) CreateTopicRequest(arg0 *quicksight.CreateTopicInput) (*request.Request, *quicksight.CreateTopicOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateTopicOutput)
	return ret0, ret1
}

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

// CreateTopicWithContext mocks base method.
func (m *MockQuickSightAPI) CreateTopicWithContext(arg0 aws.Context, arg1 *quicksight.CreateTopicInput, arg2 ...request.Option) (*quicksight.CreateTopicOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTopicWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVPCConnection mocks base method.
func (m *MockQuickSightAPI) CreateVPCConnection(arg0 *quicksight.CreateVPCConnectionInput) (*quicksight.CreateVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVPCConnection", arg0)
	ret0, _ := ret[0].(*quicksight.CreateVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVPCConnectionRequest mocks base method.
func (m *MockQuickSightAPI) CreateVPCConnectionRequest(arg0 *quicksight.CreateVPCConnectionInput) (*request.Request, *quicksight.CreateVPCConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVPCConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.CreateVPCConnectionOutput)
	return ret0, ret1
}

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

// CreateVPCConnectionWithContext mocks base method.
func (m *MockQuickSightAPI) CreateVPCConnectionWithContext(arg0 aws.Context, arg1 *quicksight.CreateVPCConnectionInput, arg2 ...request.Option) (*quicksight.CreateVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVPCConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.CreateVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAccountCustomization mocks base method.
func (m *MockQuickSightAPI) DeleteAccountCustomization(arg0 *quicksight.DeleteAccountCustomizationInput) (*quicksight.DeleteAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountCustomization", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAccountCustomizationRequest mocks base method.
func (m *MockQuickSightAPI) DeleteAccountCustomizationRequest(arg0 *quicksight.DeleteAccountCustomizationInput) (*request.Request, *quicksight.DeleteAccountCustomizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountCustomizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteAccountCustomizationOutput)
	return ret0, ret1
}

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

// DeleteAccountCustomizationWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteAccountCustomizationWithContext(arg0 aws.Context, arg1 *quicksight.DeleteAccountCustomizationInput, arg2 ...request.Option) (*quicksight.DeleteAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAccountCustomizationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAccountSubscription mocks base method.
func (m *MockQuickSightAPI) DeleteAccountSubscription(arg0 *quicksight.DeleteAccountSubscriptionInput) (*quicksight.DeleteAccountSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountSubscription", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteAccountSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAccountSubscriptionRequest mocks base method.
func (m *MockQuickSightAPI) DeleteAccountSubscriptionRequest(arg0 *quicksight.DeleteAccountSubscriptionInput) (*request.Request, *quicksight.DeleteAccountSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteAccountSubscriptionOutput)
	return ret0, ret1
}

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

// DeleteAccountSubscriptionWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteAccountSubscriptionWithContext(arg0 aws.Context, arg1 *quicksight.DeleteAccountSubscriptionInput, arg2 ...request.Option) (*quicksight.DeleteAccountSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAccountSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteAccountSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAnalysis mocks base method.
func (m *MockQuickSightAPI) DeleteAnalysis(arg0 *quicksight.DeleteAnalysisInput) (*quicksight.DeleteAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAnalysis", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAnalysisRequest mocks base method.
func (m *MockQuickSightAPI) DeleteAnalysisRequest(arg0 *quicksight.DeleteAnalysisInput) (*request.Request, *quicksight.DeleteAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteAnalysisOutput)
	return ret0, ret1
}

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

// DeleteAnalysisWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteAnalysisWithContext(arg0 aws.Context, arg1 *quicksight.DeleteAnalysisInput, arg2 ...request.Option) (*quicksight.DeleteAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDashboard mocks base method.
func (m *MockQuickSightAPI) DeleteDashboard(arg0 *quicksight.DeleteDashboardInput) (*quicksight.DeleteDashboardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDashboard", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDashboardRequest mocks base method.
func (m *MockQuickSightAPI) DeleteDashboardRequest(arg0 *quicksight.DeleteDashboardInput) (*request.Request, *quicksight.DeleteDashboardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDashboardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteDashboardOutput)
	return ret0, ret1
}

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

// DeleteDashboardWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteDashboardWithContext(arg0 aws.Context, arg1 *quicksight.DeleteDashboardInput, arg2 ...request.Option) (*quicksight.DeleteDashboardOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDashboardWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataSet mocks base method.
func (m *MockQuickSightAPI) DeleteDataSet(arg0 *quicksight.DeleteDataSetInput) (*quicksight.DeleteDataSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataSet", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataSetRefreshProperties mocks base method.
func (m *MockQuickSightAPI) DeleteDataSetRefreshProperties(arg0 *quicksight.DeleteDataSetRefreshPropertiesInput) (*quicksight.DeleteDataSetRefreshPropertiesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataSetRefreshProperties", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteDataSetRefreshPropertiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataSetRefreshPropertiesRequest mocks base method.
func (m *MockQuickSightAPI) DeleteDataSetRefreshPropertiesRequest(arg0 *quicksight.DeleteDataSetRefreshPropertiesInput) (*request.Request, *quicksight.DeleteDataSetRefreshPropertiesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataSetRefreshPropertiesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteDataSetRefreshPropertiesOutput)
	return ret0, ret1
}

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

// DeleteDataSetRefreshPropertiesWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteDataSetRefreshPropertiesWithContext(arg0 aws.Context, arg1 *quicksight.DeleteDataSetRefreshPropertiesInput, arg2 ...request.Option) (*quicksight.DeleteDataSetRefreshPropertiesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDataSetRefreshPropertiesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteDataSetRefreshPropertiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataSetRequest mocks base method.
func (m *MockQuickSightAPI) DeleteDataSetRequest(arg0 *quicksight.DeleteDataSetInput) (*request.Request, *quicksight.DeleteDataSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteDataSetOutput)
	return ret0, ret1
}

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

// DeleteDataSetWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteDataSetWithContext(arg0 aws.Context, arg1 *quicksight.DeleteDataSetInput, arg2 ...request.Option) (*quicksight.DeleteDataSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDataSetWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataSource mocks base method.
func (m *MockQuickSightAPI) DeleteDataSource(arg0 *quicksight.DeleteDataSourceInput) (*quicksight.DeleteDataSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataSource", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataSourceRequest mocks base method.
func (m *MockQuickSightAPI) DeleteDataSourceRequest(arg0 *quicksight.DeleteDataSourceInput) (*request.Request, *quicksight.DeleteDataSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteDataSourceOutput)
	return ret0, ret1
}

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

// DeleteDataSourceWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteDataSourceWithContext(arg0 aws.Context, arg1 *quicksight.DeleteDataSourceInput, arg2 ...request.Option) (*quicksight.DeleteDataSourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDataSourceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFolder mocks base method.
func (m *MockQuickSightAPI) DeleteFolder(arg0 *quicksight.DeleteFolderInput) (*quicksight.DeleteFolderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFolder", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFolderMembership mocks base method.
func (m *MockQuickSightAPI) DeleteFolderMembership(arg0 *quicksight.DeleteFolderMembershipInput) (*quicksight.DeleteFolderMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFolderMembership", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteFolderMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFolderMembershipRequest mocks base method.
func (m *MockQuickSightAPI) DeleteFolderMembershipRequest(arg0 *quicksight.DeleteFolderMembershipInput) (*request.Request, *quicksight.DeleteFolderMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFolderMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteFolderMembershipOutput)
	return ret0, ret1
}

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

// DeleteFolderMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteFolderMembershipWithContext(arg0 aws.Context, arg1 *quicksight.DeleteFolderMembershipInput, arg2 ...request.Option) (*quicksight.DeleteFolderMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFolderMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteFolderMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFolderRequest mocks base method.
func (m *MockQuickSightAPI) DeleteFolderRequest(arg0 *quicksight.DeleteFolderInput) (*request.Request, *quicksight.DeleteFolderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFolderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteFolderOutput)
	return ret0, ret1
}

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

// DeleteFolderWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteFolderWithContext(arg0 aws.Context, arg1 *quicksight.DeleteFolderInput, arg2 ...request.Option) (*quicksight.DeleteFolderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFolderWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGroup mocks base method.
func (m *MockQuickSightAPI) DeleteGroup(arg0 *quicksight.DeleteGroupInput) (*quicksight.DeleteGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroup", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGroupMembership mocks base method.
func (m *MockQuickSightAPI) DeleteGroupMembership(arg0 *quicksight.DeleteGroupMembershipInput) (*quicksight.DeleteGroupMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroupMembership", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteGroupMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGroupMembershipRequest mocks base method.
func (m *MockQuickSightAPI) DeleteGroupMembershipRequest(arg0 *quicksight.DeleteGroupMembershipInput) (*request.Request, *quicksight.DeleteGroupMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroupMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteGroupMembershipOutput)
	return ret0, ret1
}

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

// DeleteGroupMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteGroupMembershipWithContext(arg0 aws.Context, arg1 *quicksight.DeleteGroupMembershipInput, arg2 ...request.Option) (*quicksight.DeleteGroupMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteGroupMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteGroupMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGroupRequest mocks base method.
func (m *MockQuickSightAPI) DeleteGroupRequest(arg0 *quicksight.DeleteGroupInput) (*request.Request, *quicksight.DeleteGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteGroupOutput)
	return ret0, ret1
}

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

// DeleteGroupWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteGroupWithContext(arg0 aws.Context, arg1 *quicksight.DeleteGroupInput, arg2 ...request.Option) (*quicksight.DeleteGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteGroupWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIAMPolicyAssignment mocks base method.
func (m *MockQuickSightAPI) DeleteIAMPolicyAssignment(arg0 *quicksight.DeleteIAMPolicyAssignmentInput) (*quicksight.DeleteIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIAMPolicyAssignment", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIAMPolicyAssignmentRequest mocks base method.
func (m *MockQuickSightAPI) DeleteIAMPolicyAssignmentRequest(arg0 *quicksight.DeleteIAMPolicyAssignmentInput) (*request.Request, *quicksight.DeleteIAMPolicyAssignmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIAMPolicyAssignmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteIAMPolicyAssignmentOutput)
	return ret0, ret1
}

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

// DeleteIAMPolicyAssignmentWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteIAMPolicyAssignmentWithContext(arg0 aws.Context, arg1 *quicksight.DeleteIAMPolicyAssignmentInput, arg2 ...request.Option) (*quicksight.DeleteIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIAMPolicyAssignmentWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIdentityPropagationConfig mocks base method.
func (m *MockQuickSightAPI) DeleteIdentityPropagationConfig(arg0 *quicksight.DeleteIdentityPropagationConfigInput) (*quicksight.DeleteIdentityPropagationConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIdentityPropagationConfig", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteIdentityPropagationConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIdentityPropagationConfigRequest mocks base method.
func (m *MockQuickSightAPI) DeleteIdentityPropagationConfigRequest(arg0 *quicksight.DeleteIdentityPropagationConfigInput) (*request.Request, *quicksight.DeleteIdentityPropagationConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIdentityPropagationConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteIdentityPropagationConfigOutput)
	return ret0, ret1
}

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

// DeleteIdentityPropagationConfigWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteIdentityPropagationConfigWithContext(arg0 aws.Context, arg1 *quicksight.DeleteIdentityPropagationConfigInput, arg2 ...request.Option) (*quicksight.DeleteIdentityPropagationConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIdentityPropagationConfigWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteIdentityPropagationConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNamespace mocks base method.
func (m *MockQuickSightAPI) DeleteNamespace(arg0 *quicksight.DeleteNamespaceInput) (*quicksight.DeleteNamespaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespace", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteNamespaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNamespaceRequest mocks base method.
func (m *MockQuickSightAPI) DeleteNamespaceRequest(arg0 *quicksight.DeleteNamespaceInput) (*request.Request, *quicksight.DeleteNamespaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteNamespaceOutput)
	return ret0, ret1
}

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

// DeleteNamespaceWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteNamespaceWithContext(arg0 aws.Context, arg1 *quicksight.DeleteNamespaceInput, arg2 ...request.Option) (*quicksight.DeleteNamespaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNamespaceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteNamespaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) DeleteRefreshSchedule(arg0 *quicksight.DeleteRefreshScheduleInput) (*quicksight.DeleteRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) DeleteRefreshScheduleRequest(arg0 *quicksight.DeleteRefreshScheduleInput) (*request.Request, *quicksight.DeleteRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteRefreshScheduleOutput)
	return ret0, ret1
}

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

// DeleteRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.DeleteRefreshScheduleInput, arg2 ...request.Option) (*quicksight.DeleteRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRoleCustomPermission mocks base method.
func (m *MockQuickSightAPI) DeleteRoleCustomPermission(arg0 *quicksight.DeleteRoleCustomPermissionInput) (*quicksight.DeleteRoleCustomPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleCustomPermission", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteRoleCustomPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRoleCustomPermissionRequest mocks base method.
func (m *MockQuickSightAPI) DeleteRoleCustomPermissionRequest(arg0 *quicksight.DeleteRoleCustomPermissionInput) (*request.Request, *quicksight.DeleteRoleCustomPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleCustomPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteRoleCustomPermissionOutput)
	return ret0, ret1
}

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

// DeleteRoleCustomPermissionWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteRoleCustomPermissionWithContext(arg0 aws.Context, arg1 *quicksight.DeleteRoleCustomPermissionInput, arg2 ...request.Option) (*quicksight.DeleteRoleCustomPermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRoleCustomPermissionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteRoleCustomPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRoleMembership mocks base method.
func (m *MockQuickSightAPI) DeleteRoleMembership(arg0 *quicksight.DeleteRoleMembershipInput) (*quicksight.DeleteRoleMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleMembership", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteRoleMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRoleMembershipRequest mocks base method.
func (m *MockQuickSightAPI) DeleteRoleMembershipRequest(arg0 *quicksight.DeleteRoleMembershipInput) (*request.Request, *quicksight.DeleteRoleMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteRoleMembershipOutput)
	return ret0, ret1
}

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

// DeleteRoleMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteRoleMembershipWithContext(arg0 aws.Context, arg1 *quicksight.DeleteRoleMembershipInput, arg2 ...request.Option) (*quicksight.DeleteRoleMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRoleMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteRoleMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTemplate mocks base method.
func (m *MockQuickSightAPI) DeleteTemplate(arg0 *quicksight.DeleteTemplateInput) (*quicksight.DeleteTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTemplate", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTemplateAlias mocks base method.
func (m *MockQuickSightAPI) DeleteTemplateAlias(arg0 *quicksight.DeleteTemplateAliasInput) (*quicksight.DeleteTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTemplateAlias", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTemplateAliasRequest mocks base method.
func (m *MockQuickSightAPI) DeleteTemplateAliasRequest(arg0 *quicksight.DeleteTemplateAliasInput) (*request.Request, *quicksight.DeleteTemplateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTemplateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteTemplateAliasOutput)
	return ret0, ret1
}

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

// DeleteTemplateAliasWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteTemplateAliasWithContext(arg0 aws.Context, arg1 *quicksight.DeleteTemplateAliasInput, arg2 ...request.Option) (*quicksight.DeleteTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTemplateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTemplateRequest mocks base method.
func (m *MockQuickSightAPI) DeleteTemplateRequest(arg0 *quicksight.DeleteTemplateInput) (*request.Request, *quicksight.DeleteTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteTemplateOutput)
	return ret0, ret1
}

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

// DeleteTemplateWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteTemplateWithContext(arg0 aws.Context, arg1 *quicksight.DeleteTemplateInput, arg2 ...request.Option) (*quicksight.DeleteTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTheme mocks base method.
func (m *MockQuickSightAPI) DeleteTheme(arg0 *quicksight.DeleteThemeInput) (*quicksight.DeleteThemeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTheme", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteThemeAlias mocks base method.
func (m *MockQuickSightAPI) DeleteThemeAlias(arg0 *quicksight.DeleteThemeAliasInput) (*quicksight.DeleteThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThemeAlias", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteThemeAliasRequest mocks base method.
func (m *MockQuickSightAPI) DeleteThemeAliasRequest(arg0 *quicksight.DeleteThemeAliasInput) (*request.Request, *quicksight.DeleteThemeAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThemeAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteThemeAliasOutput)
	return ret0, ret1
}

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

// DeleteThemeAliasWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteThemeAliasWithContext(arg0 aws.Context, arg1 *quicksight.DeleteThemeAliasInput, arg2 ...request.Option) (*quicksight.DeleteThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteThemeAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteThemeRequest mocks base method.
func (m *MockQuickSightAPI) DeleteThemeRequest(arg0 *quicksight.DeleteThemeInput) (*request.Request, *quicksight.DeleteThemeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThemeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteThemeOutput)
	return ret0, ret1
}

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

// DeleteThemeWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteThemeWithContext(arg0 aws.Context, arg1 *quicksight.DeleteThemeInput, arg2 ...request.Option) (*quicksight.DeleteThemeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteThemeWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTopic mocks base method.
func (m *MockQuickSightAPI) DeleteTopic(arg0 *quicksight.DeleteTopicInput) (*quicksight.DeleteTopicOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTopic", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTopicRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) DeleteTopicRefreshSchedule(arg0 *quicksight.DeleteTopicRefreshScheduleInput) (*quicksight.DeleteTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTopicRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTopicRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) DeleteTopicRefreshScheduleRequest(arg0 *quicksight.DeleteTopicRefreshScheduleInput) (*request.Request, *quicksight.DeleteTopicRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTopicRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteTopicRefreshScheduleOutput)
	return ret0, ret1
}

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

// DeleteTopicRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteTopicRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.DeleteTopicRefreshScheduleInput, arg2 ...request.Option) (*quicksight.DeleteTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTopicRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTopicRequest mocks base method.
func (m *MockQuickSightAPI) DeleteTopicRequest(arg0 *quicksight.DeleteTopicInput) (*request.Request, *quicksight.DeleteTopicOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteTopicOutput)
	return ret0, ret1
}

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

// DeleteTopicWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteTopicWithContext(arg0 aws.Context, arg1 *quicksight.DeleteTopicInput, arg2 ...request.Option) (*quicksight.DeleteTopicOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTopicWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUser mocks base method.
func (m *MockQuickSightAPI) DeleteUser(arg0 *quicksight.DeleteUserInput) (*quicksight.DeleteUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUser", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUserByPrincipalId mocks base method.
func (m *MockQuickSightAPI) DeleteUserByPrincipalId(arg0 *quicksight.DeleteUserByPrincipalIdInput) (*quicksight.DeleteUserByPrincipalIdOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserByPrincipalId", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteUserByPrincipalIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUserByPrincipalIdRequest mocks base method.
func (m *MockQuickSightAPI) DeleteUserByPrincipalIdRequest(arg0 *quicksight.DeleteUserByPrincipalIdInput) (*request.Request, *quicksight.DeleteUserByPrincipalIdOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserByPrincipalIdRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteUserByPrincipalIdOutput)
	return ret0, ret1
}

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

// DeleteUserByPrincipalIdWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteUserByPrincipalIdWithContext(arg0 aws.Context, arg1 *quicksight.DeleteUserByPrincipalIdInput, arg2 ...request.Option) (*quicksight.DeleteUserByPrincipalIdOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteUserByPrincipalIdWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteUserByPrincipalIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUserRequest mocks base method.
func (m *MockQuickSightAPI) DeleteUserRequest(arg0 *quicksight.DeleteUserInput) (*request.Request, *quicksight.DeleteUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteUserOutput)
	return ret0, ret1
}

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

// DeleteUserWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteUserWithContext(arg0 aws.Context, arg1 *quicksight.DeleteUserInput, arg2 ...request.Option) (*quicksight.DeleteUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVPCConnection mocks base method.
func (m *MockQuickSightAPI) DeleteVPCConnection(arg0 *quicksight.DeleteVPCConnectionInput) (*quicksight.DeleteVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVPCConnection", arg0)
	ret0, _ := ret[0].(*quicksight.DeleteVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVPCConnectionRequest mocks base method.
func (m *MockQuickSightAPI) DeleteVPCConnectionRequest(arg0 *quicksight.DeleteVPCConnectionInput) (*request.Request, *quicksight.DeleteVPCConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVPCConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DeleteVPCConnectionOutput)
	return ret0, ret1
}

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

// DeleteVPCConnectionWithContext mocks base method.
func (m *MockQuickSightAPI) DeleteVPCConnectionWithContext(arg0 aws.Context, arg1 *quicksight.DeleteVPCConnectionInput, arg2 ...request.Option) (*quicksight.DeleteVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVPCConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DeleteVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountCustomization mocks base method.
func (m *MockQuickSightAPI) DescribeAccountCustomization(arg0 *quicksight.DescribeAccountCustomizationInput) (*quicksight.DescribeAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountCustomization", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountCustomizationRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAccountCustomizationRequest(arg0 *quicksight.DescribeAccountCustomizationInput) (*request.Request, *quicksight.DescribeAccountCustomizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountCustomizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAccountCustomizationOutput)
	return ret0, ret1
}

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

// DescribeAccountCustomizationWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAccountCustomizationWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAccountCustomizationInput, arg2 ...request.Option) (*quicksight.DescribeAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAccountCustomizationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountSettings mocks base method.
func (m *MockQuickSightAPI) DescribeAccountSettings(arg0 *quicksight.DescribeAccountSettingsInput) (*quicksight.DescribeAccountSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountSettings", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAccountSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountSettingsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAccountSettingsRequest(arg0 *quicksight.DescribeAccountSettingsInput) (*request.Request, *quicksight.DescribeAccountSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAccountSettingsOutput)
	return ret0, ret1
}

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

// DescribeAccountSettingsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAccountSettingsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAccountSettingsInput, arg2 ...request.Option) (*quicksight.DescribeAccountSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAccountSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAccountSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountSubscription mocks base method.
func (m *MockQuickSightAPI) DescribeAccountSubscription(arg0 *quicksight.DescribeAccountSubscriptionInput) (*quicksight.DescribeAccountSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountSubscription", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAccountSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountSubscriptionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAccountSubscriptionRequest(arg0 *quicksight.DescribeAccountSubscriptionInput) (*request.Request, *quicksight.DescribeAccountSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAccountSubscriptionOutput)
	return ret0, ret1
}

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

// DescribeAccountSubscriptionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAccountSubscriptionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAccountSubscriptionInput, arg2 ...request.Option) (*quicksight.DescribeAccountSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAccountSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAccountSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnalysis mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysis(arg0 *quicksight.DescribeAnalysisInput) (*quicksight.DescribeAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnalysis", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnalysisDefinition mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisDefinition(arg0 *quicksight.DescribeAnalysisDefinitionInput) (*quicksight.DescribeAnalysisDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnalysisDefinition", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAnalysisDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnalysisDefinitionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisDefinitionRequest(arg0 *quicksight.DescribeAnalysisDefinitionInput) (*request.Request, *quicksight.DescribeAnalysisDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnalysisDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAnalysisDefinitionOutput)
	return ret0, ret1
}

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

// DescribeAnalysisDefinitionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisDefinitionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAnalysisDefinitionInput, arg2 ...request.Option) (*quicksight.DescribeAnalysisDefinitionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAnalysisDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAnalysisDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnalysisPermissions mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisPermissions(arg0 *quicksight.DescribeAnalysisPermissionsInput) (*quicksight.DescribeAnalysisPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnalysisPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAnalysisPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnalysisPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisPermissionsRequest(arg0 *quicksight.DescribeAnalysisPermissionsInput) (*request.Request, *quicksight.DescribeAnalysisPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnalysisPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAnalysisPermissionsOutput)
	return ret0, ret1
}

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

// DescribeAnalysisPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAnalysisPermissionsInput, arg2 ...request.Option) (*quicksight.DescribeAnalysisPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAnalysisPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAnalysisPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAnalysisRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisRequest(arg0 *quicksight.DescribeAnalysisInput) (*request.Request, *quicksight.DescribeAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAnalysisOutput)
	return ret0, ret1
}

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

// DescribeAnalysisWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAnalysisWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAnalysisInput, arg2 ...request.Option) (*quicksight.DescribeAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAssetBundleExportJob mocks base method.
func (m *MockQuickSightAPI) DescribeAssetBundleExportJob(arg0 *quicksight.DescribeAssetBundleExportJobInput) (*quicksight.DescribeAssetBundleExportJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAssetBundleExportJob", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAssetBundleExportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAssetBundleExportJobRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAssetBundleExportJobRequest(arg0 *quicksight.DescribeAssetBundleExportJobInput) (*request.Request, *quicksight.DescribeAssetBundleExportJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAssetBundleExportJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAssetBundleExportJobOutput)
	return ret0, ret1
}

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

// DescribeAssetBundleExportJobWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAssetBundleExportJobWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAssetBundleExportJobInput, arg2 ...request.Option) (*quicksight.DescribeAssetBundleExportJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAssetBundleExportJobWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAssetBundleExportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAssetBundleImportJob mocks base method.
func (m *MockQuickSightAPI) DescribeAssetBundleImportJob(arg0 *quicksight.DescribeAssetBundleImportJobInput) (*quicksight.DescribeAssetBundleImportJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAssetBundleImportJob", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeAssetBundleImportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAssetBundleImportJobRequest mocks base method.
func (m *MockQuickSightAPI) DescribeAssetBundleImportJobRequest(arg0 *quicksight.DescribeAssetBundleImportJobInput) (*request.Request, *quicksight.DescribeAssetBundleImportJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAssetBundleImportJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeAssetBundleImportJobOutput)
	return ret0, ret1
}

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

// DescribeAssetBundleImportJobWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeAssetBundleImportJobWithContext(arg0 aws.Context, arg1 *quicksight.DescribeAssetBundleImportJobInput, arg2 ...request.Option) (*quicksight.DescribeAssetBundleImportJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAssetBundleImportJobWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeAssetBundleImportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboard mocks base method.
func (m *MockQuickSightAPI) DescribeDashboard(arg0 *quicksight.DescribeDashboardInput) (*quicksight.DescribeDashboardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboard", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardDefinition mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardDefinition(arg0 *quicksight.DescribeDashboardDefinitionInput) (*quicksight.DescribeDashboardDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardDefinition", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardDefinitionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardDefinitionRequest(arg0 *quicksight.DescribeDashboardDefinitionInput) (*request.Request, *quicksight.DescribeDashboardDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDashboardDefinitionOutput)
	return ret0, ret1
}

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

// DescribeDashboardDefinitionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardDefinitionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDashboardDefinitionInput, arg2 ...request.Option) (*quicksight.DescribeDashboardDefinitionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDashboardDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardPermissions mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardPermissions(arg0 *quicksight.DescribeDashboardPermissionsInput) (*quicksight.DescribeDashboardPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardPermissionsRequest(arg0 *quicksight.DescribeDashboardPermissionsInput) (*request.Request, *quicksight.DescribeDashboardPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDashboardPermissionsOutput)
	return ret0, ret1
}

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

// DescribeDashboardPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDashboardPermissionsInput, arg2 ...request.Option) (*quicksight.DescribeDashboardPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDashboardPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardRequest(arg0 *quicksight.DescribeDashboardInput) (*request.Request, *quicksight.DescribeDashboardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDashboardOutput)
	return ret0, ret1
}

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

// DescribeDashboardSnapshotJob mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardSnapshotJob(arg0 *quicksight.DescribeDashboardSnapshotJobInput) (*quicksight.DescribeDashboardSnapshotJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardSnapshotJob", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardSnapshotJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardSnapshotJobRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardSnapshotJobRequest(arg0 *quicksight.DescribeDashboardSnapshotJobInput) (*request.Request, *quicksight.DescribeDashboardSnapshotJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardSnapshotJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDashboardSnapshotJobOutput)
	return ret0, ret1
}

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

// DescribeDashboardSnapshotJobResult mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardSnapshotJobResult(arg0 *quicksight.DescribeDashboardSnapshotJobResultInput) (*quicksight.DescribeDashboardSnapshotJobResultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardSnapshotJobResult", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardSnapshotJobResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardSnapshotJobResultRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardSnapshotJobResultRequest(arg0 *quicksight.DescribeDashboardSnapshotJobResultInput) (*request.Request, *quicksight.DescribeDashboardSnapshotJobResultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDashboardSnapshotJobResultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDashboardSnapshotJobResultOutput)
	return ret0, ret1
}

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

// DescribeDashboardSnapshotJobResultWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardSnapshotJobResultWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDashboardSnapshotJobResultInput, arg2 ...request.Option) (*quicksight.DescribeDashboardSnapshotJobResultOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDashboardSnapshotJobResultWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardSnapshotJobResultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardSnapshotJobWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardSnapshotJobWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDashboardSnapshotJobInput, arg2 ...request.Option) (*quicksight.DescribeDashboardSnapshotJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDashboardSnapshotJobWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardSnapshotJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDashboardWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDashboardWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDashboardInput, arg2 ...request.Option) (*quicksight.DescribeDashboardOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDashboardWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSet mocks base method.
func (m *MockQuickSightAPI) DescribeDataSet(arg0 *quicksight.DescribeDataSetInput) (*quicksight.DescribeDataSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSet", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSetPermissions mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetPermissions(arg0 *quicksight.DescribeDataSetPermissionsInput) (*quicksight.DescribeDataSetPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSetPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDataSetPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSetPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetPermissionsRequest(arg0 *quicksight.DescribeDataSetPermissionsInput) (*request.Request, *quicksight.DescribeDataSetPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSetPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDataSetPermissionsOutput)
	return ret0, ret1
}

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

// DescribeDataSetPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDataSetPermissionsInput, arg2 ...request.Option) (*quicksight.DescribeDataSetPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDataSetPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDataSetPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSetRefreshProperties mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetRefreshProperties(arg0 *quicksight.DescribeDataSetRefreshPropertiesInput) (*quicksight.DescribeDataSetRefreshPropertiesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSetRefreshProperties", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDataSetRefreshPropertiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSetRefreshPropertiesRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetRefreshPropertiesRequest(arg0 *quicksight.DescribeDataSetRefreshPropertiesInput) (*request.Request, *quicksight.DescribeDataSetRefreshPropertiesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSetRefreshPropertiesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDataSetRefreshPropertiesOutput)
	return ret0, ret1
}

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

// DescribeDataSetRefreshPropertiesWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetRefreshPropertiesWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDataSetRefreshPropertiesInput, arg2 ...request.Option) (*quicksight.DescribeDataSetRefreshPropertiesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDataSetRefreshPropertiesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDataSetRefreshPropertiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSetRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetRequest(arg0 *quicksight.DescribeDataSetInput) (*request.Request, *quicksight.DescribeDataSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDataSetOutput)
	return ret0, ret1
}

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

// DescribeDataSetWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDataSetWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDataSetInput, arg2 ...request.Option) (*quicksight.DescribeDataSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDataSetWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSource mocks base method.
func (m *MockQuickSightAPI) DescribeDataSource(arg0 *quicksight.DescribeDataSourceInput) (*quicksight.DescribeDataSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSource", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSourcePermissions mocks base method.
func (m *MockQuickSightAPI) DescribeDataSourcePermissions(arg0 *quicksight.DescribeDataSourcePermissionsInput) (*quicksight.DescribeDataSourcePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSourcePermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeDataSourcePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSourcePermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDataSourcePermissionsRequest(arg0 *quicksight.DescribeDataSourcePermissionsInput) (*request.Request, *quicksight.DescribeDataSourcePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSourcePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDataSourcePermissionsOutput)
	return ret0, ret1
}

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

// DescribeDataSourcePermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDataSourcePermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDataSourcePermissionsInput, arg2 ...request.Option) (*quicksight.DescribeDataSourcePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDataSourcePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDataSourcePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDataSourceRequest mocks base method.
func (m *MockQuickSightAPI) DescribeDataSourceRequest(arg0 *quicksight.DescribeDataSourceInput) (*request.Request, *quicksight.DescribeDataSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDataSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeDataSourceOutput)
	return ret0, ret1
}

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

// DescribeDataSourceWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeDataSourceWithContext(arg0 aws.Context, arg1 *quicksight.DescribeDataSourceInput, arg2 ...request.Option) (*quicksight.DescribeDataSourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDataSourceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFolder mocks base method.
func (m *MockQuickSightAPI) DescribeFolder(arg0 *quicksight.DescribeFolderInput) (*quicksight.DescribeFolderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolder", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFolderPermissions mocks base method.
func (m *MockQuickSightAPI) DescribeFolderPermissions(arg0 *quicksight.DescribeFolderPermissionsInput) (*quicksight.DescribeFolderPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeFolderPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFolderPermissionsPages mocks base method.
func (m *MockQuickSightAPI) DescribeFolderPermissionsPages(arg0 *quicksight.DescribeFolderPermissionsInput, arg1 func(*quicksight.DescribeFolderPermissionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderPermissionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFolderPermissionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeFolderPermissionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.DescribeFolderPermissionsInput, arg2 func(*quicksight.DescribeFolderPermissionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFolderPermissionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFolderPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeFolderPermissionsRequest(arg0 *quicksight.DescribeFolderPermissionsInput) (*request.Request, *quicksight.DescribeFolderPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeFolderPermissionsOutput)
	return ret0, ret1
}

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

// DescribeFolderPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeFolderPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeFolderPermissionsInput, arg2 ...request.Option) (*quicksight.DescribeFolderPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFolderPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeFolderPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFolderRequest mocks base method.
func (m *MockQuickSightAPI) DescribeFolderRequest(arg0 *quicksight.DescribeFolderInput) (*request.Request, *quicksight.DescribeFolderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeFolderOutput)
	return ret0, ret1
}

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

// DescribeFolderResolvedPermissions mocks base method.
func (m *MockQuickSightAPI) DescribeFolderResolvedPermissions(arg0 *quicksight.DescribeFolderResolvedPermissionsInput) (*quicksight.DescribeFolderResolvedPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderResolvedPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeFolderResolvedPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFolderResolvedPermissionsPages mocks base method.
func (m *MockQuickSightAPI) DescribeFolderResolvedPermissionsPages(arg0 *quicksight.DescribeFolderResolvedPermissionsInput, arg1 func(*quicksight.DescribeFolderResolvedPermissionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderResolvedPermissionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFolderResolvedPermissionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeFolderResolvedPermissionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.DescribeFolderResolvedPermissionsInput, arg2 func(*quicksight.DescribeFolderResolvedPermissionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFolderResolvedPermissionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFolderResolvedPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeFolderResolvedPermissionsRequest(arg0 *quicksight.DescribeFolderResolvedPermissionsInput) (*request.Request, *quicksight.DescribeFolderResolvedPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFolderResolvedPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeFolderResolvedPermissionsOutput)
	return ret0, ret1
}

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

// DescribeFolderResolvedPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeFolderResolvedPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeFolderResolvedPermissionsInput, arg2 ...request.Option) (*quicksight.DescribeFolderResolvedPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFolderResolvedPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeFolderResolvedPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFolderWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeFolderWithContext(arg0 aws.Context, arg1 *quicksight.DescribeFolderInput, arg2 ...request.Option) (*quicksight.DescribeFolderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFolderWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGroup mocks base method.
func (m *MockQuickSightAPI) DescribeGroup(arg0 *quicksight.DescribeGroupInput) (*quicksight.DescribeGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGroup", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGroupMembership mocks base method.
func (m *MockQuickSightAPI) DescribeGroupMembership(arg0 *quicksight.DescribeGroupMembershipInput) (*quicksight.DescribeGroupMembershipOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGroupMembership", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeGroupMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGroupMembershipRequest mocks base method.
func (m *MockQuickSightAPI) DescribeGroupMembershipRequest(arg0 *quicksight.DescribeGroupMembershipInput) (*request.Request, *quicksight.DescribeGroupMembershipOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGroupMembershipRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeGroupMembershipOutput)
	return ret0, ret1
}

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

// DescribeGroupMembershipWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeGroupMembershipWithContext(arg0 aws.Context, arg1 *quicksight.DescribeGroupMembershipInput, arg2 ...request.Option) (*quicksight.DescribeGroupMembershipOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGroupMembershipWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeGroupMembershipOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGroupRequest mocks base method.
func (m *MockQuickSightAPI) DescribeGroupRequest(arg0 *quicksight.DescribeGroupInput) (*request.Request, *quicksight.DescribeGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeGroupOutput)
	return ret0, ret1
}

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

// DescribeGroupWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeGroupWithContext(arg0 aws.Context, arg1 *quicksight.DescribeGroupInput, arg2 ...request.Option) (*quicksight.DescribeGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGroupWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIAMPolicyAssignment mocks base method.
func (m *MockQuickSightAPI) DescribeIAMPolicyAssignment(arg0 *quicksight.DescribeIAMPolicyAssignmentInput) (*quicksight.DescribeIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIAMPolicyAssignment", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIAMPolicyAssignmentRequest mocks base method.
func (m *MockQuickSightAPI) DescribeIAMPolicyAssignmentRequest(arg0 *quicksight.DescribeIAMPolicyAssignmentInput) (*request.Request, *quicksight.DescribeIAMPolicyAssignmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIAMPolicyAssignmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeIAMPolicyAssignmentOutput)
	return ret0, ret1
}

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

// DescribeIAMPolicyAssignmentWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeIAMPolicyAssignmentWithContext(arg0 aws.Context, arg1 *quicksight.DescribeIAMPolicyAssignmentInput, arg2 ...request.Option) (*quicksight.DescribeIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIAMPolicyAssignmentWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIngestion mocks base method.
func (m *MockQuickSightAPI) DescribeIngestion(arg0 *quicksight.DescribeIngestionInput) (*quicksight.DescribeIngestionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIngestion", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeIngestionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIngestionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeIngestionRequest(arg0 *quicksight.DescribeIngestionInput) (*request.Request, *quicksight.DescribeIngestionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIngestionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeIngestionOutput)
	return ret0, ret1
}

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

// DescribeIngestionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeIngestionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeIngestionInput, arg2 ...request.Option) (*quicksight.DescribeIngestionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIngestionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeIngestionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpRestriction mocks base method.
func (m *MockQuickSightAPI) DescribeIpRestriction(arg0 *quicksight.DescribeIpRestrictionInput) (*quicksight.DescribeIpRestrictionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpRestriction", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeIpRestrictionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpRestrictionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeIpRestrictionRequest(arg0 *quicksight.DescribeIpRestrictionInput) (*request.Request, *quicksight.DescribeIpRestrictionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpRestrictionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeIpRestrictionOutput)
	return ret0, ret1
}

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

// DescribeIpRestrictionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeIpRestrictionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeIpRestrictionInput, arg2 ...request.Option) (*quicksight.DescribeIpRestrictionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpRestrictionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeIpRestrictionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeKeyRegistration mocks base method.
func (m *MockQuickSightAPI) DescribeKeyRegistration(arg0 *quicksight.DescribeKeyRegistrationInput) (*quicksight.DescribeKeyRegistrationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKeyRegistration", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeKeyRegistrationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeKeyRegistrationRequest mocks base method.
func (m *MockQuickSightAPI) DescribeKeyRegistrationRequest(arg0 *quicksight.DescribeKeyRegistrationInput) (*request.Request, *quicksight.DescribeKeyRegistrationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKeyRegistrationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeKeyRegistrationOutput)
	return ret0, ret1
}

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

// DescribeKeyRegistrationWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeKeyRegistrationWithContext(arg0 aws.Context, arg1 *quicksight.DescribeKeyRegistrationInput, arg2 ...request.Option) (*quicksight.DescribeKeyRegistrationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeKeyRegistrationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeKeyRegistrationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNamespace mocks base method.
func (m *MockQuickSightAPI) DescribeNamespace(arg0 *quicksight.DescribeNamespaceInput) (*quicksight.DescribeNamespaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNamespace", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeNamespaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNamespaceRequest mocks base method.
func (m *MockQuickSightAPI) DescribeNamespaceRequest(arg0 *quicksight.DescribeNamespaceInput) (*request.Request, *quicksight.DescribeNamespaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNamespaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeNamespaceOutput)
	return ret0, ret1
}

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

// DescribeNamespaceWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeNamespaceWithContext(arg0 aws.Context, arg1 *quicksight.DescribeNamespaceInput, arg2 ...request.Option) (*quicksight.DescribeNamespaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNamespaceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeNamespaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) DescribeRefreshSchedule(arg0 *quicksight.DescribeRefreshScheduleInput) (*quicksight.DescribeRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) DescribeRefreshScheduleRequest(arg0 *quicksight.DescribeRefreshScheduleInput) (*request.Request, *quicksight.DescribeRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeRefreshScheduleOutput)
	return ret0, ret1
}

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

// DescribeRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.DescribeRefreshScheduleInput, arg2 ...request.Option) (*quicksight.DescribeRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRoleCustomPermission mocks base method.
func (m *MockQuickSightAPI) DescribeRoleCustomPermission(arg0 *quicksight.DescribeRoleCustomPermissionInput) (*quicksight.DescribeRoleCustomPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRoleCustomPermission", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeRoleCustomPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRoleCustomPermissionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeRoleCustomPermissionRequest(arg0 *quicksight.DescribeRoleCustomPermissionInput) (*request.Request, *quicksight.DescribeRoleCustomPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRoleCustomPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeRoleCustomPermissionOutput)
	return ret0, ret1
}

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

// DescribeRoleCustomPermissionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeRoleCustomPermissionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeRoleCustomPermissionInput, arg2 ...request.Option) (*quicksight.DescribeRoleCustomPermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeRoleCustomPermissionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeRoleCustomPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplate mocks base method.
func (m *MockQuickSightAPI) DescribeTemplate(arg0 *quicksight.DescribeTemplateInput) (*quicksight.DescribeTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplate", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplateAlias mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateAlias(arg0 *quicksight.DescribeTemplateAliasInput) (*quicksight.DescribeTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplateAlias", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplateAliasRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateAliasRequest(arg0 *quicksight.DescribeTemplateAliasInput) (*request.Request, *quicksight.DescribeTemplateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTemplateAliasOutput)
	return ret0, ret1
}

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

// DescribeTemplateAliasWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateAliasWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTemplateAliasInput, arg2 ...request.Option) (*quicksight.DescribeTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTemplateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplateDefinition mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateDefinition(arg0 *quicksight.DescribeTemplateDefinitionInput) (*quicksight.DescribeTemplateDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplateDefinition", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTemplateDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplateDefinitionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateDefinitionRequest(arg0 *quicksight.DescribeTemplateDefinitionInput) (*request.Request, *quicksight.DescribeTemplateDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplateDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTemplateDefinitionOutput)
	return ret0, ret1
}

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

// DescribeTemplateDefinitionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateDefinitionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTemplateDefinitionInput, arg2 ...request.Option) (*quicksight.DescribeTemplateDefinitionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTemplateDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTemplateDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplatePermissions mocks base method.
func (m *MockQuickSightAPI) DescribeTemplatePermissions(arg0 *quicksight.DescribeTemplatePermissionsInput) (*quicksight.DescribeTemplatePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplatePermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTemplatePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplatePermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTemplatePermissionsRequest(arg0 *quicksight.DescribeTemplatePermissionsInput) (*request.Request, *quicksight.DescribeTemplatePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplatePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTemplatePermissionsOutput)
	return ret0, ret1
}

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

// DescribeTemplatePermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTemplatePermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTemplatePermissionsInput, arg2 ...request.Option) (*quicksight.DescribeTemplatePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTemplatePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTemplatePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTemplateRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateRequest(arg0 *quicksight.DescribeTemplateInput) (*request.Request, *quicksight.DescribeTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTemplateOutput)
	return ret0, ret1
}

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

// DescribeTemplateWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTemplateWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTemplateInput, arg2 ...request.Option) (*quicksight.DescribeTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTheme mocks base method.
func (m *MockQuickSightAPI) DescribeTheme(arg0 *quicksight.DescribeThemeInput) (*quicksight.DescribeThemeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTheme", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeThemeAlias mocks base method.
func (m *MockQuickSightAPI) DescribeThemeAlias(arg0 *quicksight.DescribeThemeAliasInput) (*quicksight.DescribeThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeThemeAlias", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeThemeAliasRequest mocks base method.
func (m *MockQuickSightAPI) DescribeThemeAliasRequest(arg0 *quicksight.DescribeThemeAliasInput) (*request.Request, *quicksight.DescribeThemeAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeThemeAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeThemeAliasOutput)
	return ret0, ret1
}

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

// DescribeThemeAliasWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeThemeAliasWithContext(arg0 aws.Context, arg1 *quicksight.DescribeThemeAliasInput, arg2 ...request.Option) (*quicksight.DescribeThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeThemeAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeThemePermissions mocks base method.
func (m *MockQuickSightAPI) DescribeThemePermissions(arg0 *quicksight.DescribeThemePermissionsInput) (*quicksight.DescribeThemePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeThemePermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeThemePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeThemePermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeThemePermissionsRequest(arg0 *quicksight.DescribeThemePermissionsInput) (*request.Request, *quicksight.DescribeThemePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeThemePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeThemePermissionsOutput)
	return ret0, ret1
}

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

// DescribeThemePermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeThemePermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeThemePermissionsInput, arg2 ...request.Option) (*quicksight.DescribeThemePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeThemePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeThemePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeThemeRequest mocks base method.
func (m *MockQuickSightAPI) DescribeThemeRequest(arg0 *quicksight.DescribeThemeInput) (*request.Request, *quicksight.DescribeThemeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeThemeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeThemeOutput)
	return ret0, ret1
}

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

// DescribeThemeWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeThemeWithContext(arg0 aws.Context, arg1 *quicksight.DescribeThemeInput, arg2 ...request.Option) (*quicksight.DescribeThemeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeThemeWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopic mocks base method.
func (m *MockQuickSightAPI) DescribeTopic(arg0 *quicksight.DescribeTopicInput) (*quicksight.DescribeTopicOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopic", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicPermissions mocks base method.
func (m *MockQuickSightAPI) DescribeTopicPermissions(arg0 *quicksight.DescribeTopicPermissionsInput) (*quicksight.DescribeTopicPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTopicPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTopicPermissionsRequest(arg0 *quicksight.DescribeTopicPermissionsInput) (*request.Request, *quicksight.DescribeTopicPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTopicPermissionsOutput)
	return ret0, ret1
}

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

// DescribeTopicPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTopicPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTopicPermissionsInput, arg2 ...request.Option) (*quicksight.DescribeTopicPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTopicPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTopicPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicRefresh mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRefresh(arg0 *quicksight.DescribeTopicRefreshInput) (*quicksight.DescribeTopicRefreshOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicRefresh", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTopicRefreshOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicRefreshRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRefreshRequest(arg0 *quicksight.DescribeTopicRefreshInput) (*request.Request, *quicksight.DescribeTopicRefreshOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicRefreshRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTopicRefreshOutput)
	return ret0, ret1
}

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

// DescribeTopicRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRefreshSchedule(arg0 *quicksight.DescribeTopicRefreshScheduleInput) (*quicksight.DescribeTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRefreshScheduleRequest(arg0 *quicksight.DescribeTopicRefreshScheduleInput) (*request.Request, *quicksight.DescribeTopicRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTopicRefreshScheduleOutput)
	return ret0, ret1
}

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

// DescribeTopicRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTopicRefreshScheduleInput, arg2 ...request.Option) (*quicksight.DescribeTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTopicRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicRefreshWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRefreshWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTopicRefreshInput, arg2 ...request.Option) (*quicksight.DescribeTopicRefreshOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTopicRefreshWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTopicRefreshOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTopicRequest mocks base method.
func (m *MockQuickSightAPI) DescribeTopicRequest(arg0 *quicksight.DescribeTopicInput) (*request.Request, *quicksight.DescribeTopicOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeTopicOutput)
	return ret0, ret1
}

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

// DescribeTopicWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeTopicWithContext(arg0 aws.Context, arg1 *quicksight.DescribeTopicInput, arg2 ...request.Option) (*quicksight.DescribeTopicOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTopicWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeUser mocks base method.
func (m *MockQuickSightAPI) DescribeUser(arg0 *quicksight.DescribeUserInput) (*quicksight.DescribeUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUser", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeUserRequest mocks base method.
func (m *MockQuickSightAPI) DescribeUserRequest(arg0 *quicksight.DescribeUserInput) (*request.Request, *quicksight.DescribeUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeUserOutput)
	return ret0, ret1
}

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

// DescribeUserWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeUserWithContext(arg0 aws.Context, arg1 *quicksight.DescribeUserInput, arg2 ...request.Option) (*quicksight.DescribeUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVPCConnection mocks base method.
func (m *MockQuickSightAPI) DescribeVPCConnection(arg0 *quicksight.DescribeVPCConnectionInput) (*quicksight.DescribeVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVPCConnection", arg0)
	ret0, _ := ret[0].(*quicksight.DescribeVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVPCConnectionRequest mocks base method.
func (m *MockQuickSightAPI) DescribeVPCConnectionRequest(arg0 *quicksight.DescribeVPCConnectionInput) (*request.Request, *quicksight.DescribeVPCConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVPCConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.DescribeVPCConnectionOutput)
	return ret0, ret1
}

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

// DescribeVPCConnectionWithContext mocks base method.
func (m *MockQuickSightAPI) DescribeVPCConnectionWithContext(arg0 aws.Context, arg1 *quicksight.DescribeVPCConnectionInput, arg2 ...request.Option) (*quicksight.DescribeVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVPCConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.DescribeVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateEmbedUrlForAnonymousUser mocks base method.
func (m *MockQuickSightAPI) GenerateEmbedUrlForAnonymousUser(arg0 *quicksight.GenerateEmbedUrlForAnonymousUserInput) (*quicksight.GenerateEmbedUrlForAnonymousUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateEmbedUrlForAnonymousUser", arg0)
	ret0, _ := ret[0].(*quicksight.GenerateEmbedUrlForAnonymousUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateEmbedUrlForAnonymousUserRequest mocks base method.
func (m *MockQuickSightAPI) GenerateEmbedUrlForAnonymousUserRequest(arg0 *quicksight.GenerateEmbedUrlForAnonymousUserInput) (*request.Request, *quicksight.GenerateEmbedUrlForAnonymousUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateEmbedUrlForAnonymousUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.GenerateEmbedUrlForAnonymousUserOutput)
	return ret0, ret1
}

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

// GenerateEmbedUrlForAnonymousUserWithContext mocks base method.
func (m *MockQuickSightAPI) GenerateEmbedUrlForAnonymousUserWithContext(arg0 aws.Context, arg1 *quicksight.GenerateEmbedUrlForAnonymousUserInput, arg2 ...request.Option) (*quicksight.GenerateEmbedUrlForAnonymousUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateEmbedUrlForAnonymousUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.GenerateEmbedUrlForAnonymousUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateEmbedUrlForRegisteredUser mocks base method.
func (m *MockQuickSightAPI) GenerateEmbedUrlForRegisteredUser(arg0 *quicksight.GenerateEmbedUrlForRegisteredUserInput) (*quicksight.GenerateEmbedUrlForRegisteredUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateEmbedUrlForRegisteredUser", arg0)
	ret0, _ := ret[0].(*quicksight.GenerateEmbedUrlForRegisteredUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateEmbedUrlForRegisteredUserRequest mocks base method.
func (m *MockQuickSightAPI) GenerateEmbedUrlForRegisteredUserRequest(arg0 *quicksight.GenerateEmbedUrlForRegisteredUserInput) (*request.Request, *quicksight.GenerateEmbedUrlForRegisteredUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateEmbedUrlForRegisteredUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.GenerateEmbedUrlForRegisteredUserOutput)
	return ret0, ret1
}

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

// GenerateEmbedUrlForRegisteredUserWithContext mocks base method.
func (m *MockQuickSightAPI) GenerateEmbedUrlForRegisteredUserWithContext(arg0 aws.Context, arg1 *quicksight.GenerateEmbedUrlForRegisteredUserInput, arg2 ...request.Option) (*quicksight.GenerateEmbedUrlForRegisteredUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateEmbedUrlForRegisteredUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.GenerateEmbedUrlForRegisteredUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDashboardEmbedUrl mocks base method.
func (m *MockQuickSightAPI) GetDashboardEmbedUrl(arg0 *quicksight.GetDashboardEmbedUrlInput) (*quicksight.GetDashboardEmbedUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDashboardEmbedUrl", arg0)
	ret0, _ := ret[0].(*quicksight.GetDashboardEmbedUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDashboardEmbedUrlRequest mocks base method.
func (m *MockQuickSightAPI) GetDashboardEmbedUrlRequest(arg0 *quicksight.GetDashboardEmbedUrlInput) (*request.Request, *quicksight.GetDashboardEmbedUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDashboardEmbedUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.GetDashboardEmbedUrlOutput)
	return ret0, ret1
}

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

// GetDashboardEmbedUrlWithContext mocks base method.
func (m *MockQuickSightAPI) GetDashboardEmbedUrlWithContext(arg0 aws.Context, arg1 *quicksight.GetDashboardEmbedUrlInput, arg2 ...request.Option) (*quicksight.GetDashboardEmbedUrlOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDashboardEmbedUrlWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.GetDashboardEmbedUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSessionEmbedUrl mocks base method.
func (m *MockQuickSightAPI) GetSessionEmbedUrl(arg0 *quicksight.GetSessionEmbedUrlInput) (*quicksight.GetSessionEmbedUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSessionEmbedUrl", arg0)
	ret0, _ := ret[0].(*quicksight.GetSessionEmbedUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSessionEmbedUrlRequest mocks base method.
func (m *MockQuickSightAPI) GetSessionEmbedUrlRequest(arg0 *quicksight.GetSessionEmbedUrlInput) (*request.Request, *quicksight.GetSessionEmbedUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSessionEmbedUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.GetSessionEmbedUrlOutput)
	return ret0, ret1
}

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

// GetSessionEmbedUrlWithContext mocks base method.
func (m *MockQuickSightAPI) GetSessionEmbedUrlWithContext(arg0 aws.Context, arg1 *quicksight.GetSessionEmbedUrlInput, arg2 ...request.Option) (*quicksight.GetSessionEmbedUrlOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSessionEmbedUrlWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.GetSessionEmbedUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAnalyses mocks base method.
func (m *MockQuickSightAPI) ListAnalyses(arg0 *quicksight.ListAnalysesInput) (*quicksight.ListAnalysesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAnalyses", arg0)
	ret0, _ := ret[0].(*quicksight.ListAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAnalysesPages mocks base method.
func (m *MockQuickSightAPI) ListAnalysesPages(arg0 *quicksight.ListAnalysesInput, arg1 func(*quicksight.ListAnalysesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAnalysesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAnalysesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListAnalysesPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListAnalysesInput, arg2 func(*quicksight.ListAnalysesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAnalysesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAnalysesRequest mocks base method.
func (m *MockQuickSightAPI) ListAnalysesRequest(arg0 *quicksight.ListAnalysesInput) (*request.Request, *quicksight.ListAnalysesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAnalysesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListAnalysesOutput)
	return ret0, ret1
}

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

// ListAnalysesWithContext mocks base method.
func (m *MockQuickSightAPI) ListAnalysesWithContext(arg0 aws.Context, arg1 *quicksight.ListAnalysesInput, arg2 ...request.Option) (*quicksight.ListAnalysesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAnalysesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAssetBundleExportJobs mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleExportJobs(arg0 *quicksight.ListAssetBundleExportJobsInput) (*quicksight.ListAssetBundleExportJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetBundleExportJobs", arg0)
	ret0, _ := ret[0].(*quicksight.ListAssetBundleExportJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAssetBundleExportJobsPages mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleExportJobsPages(arg0 *quicksight.ListAssetBundleExportJobsInput, arg1 func(*quicksight.ListAssetBundleExportJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetBundleExportJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAssetBundleExportJobsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleExportJobsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListAssetBundleExportJobsInput, arg2 func(*quicksight.ListAssetBundleExportJobsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssetBundleExportJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAssetBundleExportJobsRequest mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleExportJobsRequest(arg0 *quicksight.ListAssetBundleExportJobsInput) (*request.Request, *quicksight.ListAssetBundleExportJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetBundleExportJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListAssetBundleExportJobsOutput)
	return ret0, ret1
}

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

// ListAssetBundleExportJobsWithContext mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleExportJobsWithContext(arg0 aws.Context, arg1 *quicksight.ListAssetBundleExportJobsInput, arg2 ...request.Option) (*quicksight.ListAssetBundleExportJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssetBundleExportJobsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListAssetBundleExportJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAssetBundleImportJobs mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleImportJobs(arg0 *quicksight.ListAssetBundleImportJobsInput) (*quicksight.ListAssetBundleImportJobsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetBundleImportJobs", arg0)
	ret0, _ := ret[0].(*quicksight.ListAssetBundleImportJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAssetBundleImportJobsPages mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleImportJobsPages(arg0 *quicksight.ListAssetBundleImportJobsInput, arg1 func(*quicksight.ListAssetBundleImportJobsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetBundleImportJobsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAssetBundleImportJobsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleImportJobsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListAssetBundleImportJobsInput, arg2 func(*quicksight.ListAssetBundleImportJobsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssetBundleImportJobsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAssetBundleImportJobsRequest mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleImportJobsRequest(arg0 *quicksight.ListAssetBundleImportJobsInput) (*request.Request, *quicksight.ListAssetBundleImportJobsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetBundleImportJobsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListAssetBundleImportJobsOutput)
	return ret0, ret1
}

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

// ListAssetBundleImportJobsWithContext mocks base method.
func (m *MockQuickSightAPI) ListAssetBundleImportJobsWithContext(arg0 aws.Context, arg1 *quicksight.ListAssetBundleImportJobsInput, arg2 ...request.Option) (*quicksight.ListAssetBundleImportJobsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssetBundleImportJobsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListAssetBundleImportJobsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDashboardVersions mocks base method.
func (m *MockQuickSightAPI) ListDashboardVersions(arg0 *quicksight.ListDashboardVersionsInput) (*quicksight.ListDashboardVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardVersions", arg0)
	ret0, _ := ret[0].(*quicksight.ListDashboardVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDashboardVersionsPages mocks base method.
func (m *MockQuickSightAPI) ListDashboardVersionsPages(arg0 *quicksight.ListDashboardVersionsInput, arg1 func(*quicksight.ListDashboardVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDashboardVersionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListDashboardVersionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListDashboardVersionsInput, arg2 func(*quicksight.ListDashboardVersionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDashboardVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDashboardVersionsRequest mocks base method.
func (m *MockQuickSightAPI) ListDashboardVersionsRequest(arg0 *quicksight.ListDashboardVersionsInput) (*request.Request, *quicksight.ListDashboardVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListDashboardVersionsOutput)
	return ret0, ret1
}

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

// ListDashboardVersionsWithContext mocks base method.
func (m *MockQuickSightAPI) ListDashboardVersionsWithContext(arg0 aws.Context, arg1 *quicksight.ListDashboardVersionsInput, arg2 ...request.Option) (*quicksight.ListDashboardVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDashboardVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListDashboardVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDashboards mocks base method.
func (m *MockQuickSightAPI) ListDashboards(arg0 *quicksight.ListDashboardsInput) (*quicksight.ListDashboardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboards", arg0)
	ret0, _ := ret[0].(*quicksight.ListDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDashboardsPages mocks base method.
func (m *MockQuickSightAPI) ListDashboardsPages(arg0 *quicksight.ListDashboardsInput, arg1 func(*quicksight.ListDashboardsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDashboardsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListDashboardsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListDashboardsInput, arg2 func(*quicksight.ListDashboardsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDashboardsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDashboardsRequest mocks base method.
func (m *MockQuickSightAPI) ListDashboardsRequest(arg0 *quicksight.ListDashboardsInput) (*request.Request, *quicksight.ListDashboardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDashboardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListDashboardsOutput)
	return ret0, ret1
}

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

// ListDashboardsWithContext mocks base method.
func (m *MockQuickSightAPI) ListDashboardsWithContext(arg0 aws.Context, arg1 *quicksight.ListDashboardsInput, arg2 ...request.Option) (*quicksight.ListDashboardsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDashboardsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDataSets mocks base method.
func (m *MockQuickSightAPI) ListDataSets(arg0 *quicksight.ListDataSetsInput) (*quicksight.ListDataSetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataSets", arg0)
	ret0, _ := ret[0].(*quicksight.ListDataSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDataSetsPages mocks base method.
func (m *MockQuickSightAPI) ListDataSetsPages(arg0 *quicksight.ListDataSetsInput, arg1 func(*quicksight.ListDataSetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataSetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDataSetsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListDataSetsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListDataSetsInput, arg2 func(*quicksight.ListDataSetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDataSetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDataSetsRequest mocks base method.
func (m *MockQuickSightAPI) ListDataSetsRequest(arg0 *quicksight.ListDataSetsInput) (*request.Request, *quicksight.ListDataSetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataSetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListDataSetsOutput)
	return ret0, ret1
}

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

// ListDataSetsWithContext mocks base method.
func (m *MockQuickSightAPI) ListDataSetsWithContext(arg0 aws.Context, arg1 *quicksight.ListDataSetsInput, arg2 ...request.Option) (*quicksight.ListDataSetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDataSetsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListDataSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDataSources mocks base method.
func (m *MockQuickSightAPI) ListDataSources(arg0 *quicksight.ListDataSourcesInput) (*quicksight.ListDataSourcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataSources", arg0)
	ret0, _ := ret[0].(*quicksight.ListDataSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDataSourcesPages mocks base method.
func (m *MockQuickSightAPI) ListDataSourcesPages(arg0 *quicksight.ListDataSourcesInput, arg1 func(*quicksight.ListDataSourcesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataSourcesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDataSourcesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListDataSourcesPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListDataSourcesInput, arg2 func(*quicksight.ListDataSourcesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDataSourcesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDataSourcesRequest mocks base method.
func (m *MockQuickSightAPI) ListDataSourcesRequest(arg0 *quicksight.ListDataSourcesInput) (*request.Request, *quicksight.ListDataSourcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataSourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListDataSourcesOutput)
	return ret0, ret1
}

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

// ListDataSourcesWithContext mocks base method.
func (m *MockQuickSightAPI) ListDataSourcesWithContext(arg0 aws.Context, arg1 *quicksight.ListDataSourcesInput, arg2 ...request.Option) (*quicksight.ListDataSourcesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDataSourcesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListDataSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFolderMembers mocks base method.
func (m *MockQuickSightAPI) ListFolderMembers(arg0 *quicksight.ListFolderMembersInput) (*quicksight.ListFolderMembersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFolderMembers", arg0)
	ret0, _ := ret[0].(*quicksight.ListFolderMembersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFolderMembersPages mocks base method.
func (m *MockQuickSightAPI) ListFolderMembersPages(arg0 *quicksight.ListFolderMembersInput, arg1 func(*quicksight.ListFolderMembersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFolderMembersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFolderMembersPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListFolderMembersPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListFolderMembersInput, arg2 func(*quicksight.ListFolderMembersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFolderMembersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFolderMembersRequest mocks base method.
func (m *MockQuickSightAPI) ListFolderMembersRequest(arg0 *quicksight.ListFolderMembersInput) (*request.Request, *quicksight.ListFolderMembersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFolderMembersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListFolderMembersOutput)
	return ret0, ret1
}

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

// ListFolderMembersWithContext mocks base method.
func (m *MockQuickSightAPI) ListFolderMembersWithContext(arg0 aws.Context, arg1 *quicksight.ListFolderMembersInput, arg2 ...request.Option) (*quicksight.ListFolderMembersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFolderMembersWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListFolderMembersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFolders mocks base method.
func (m *MockQuickSightAPI) ListFolders(arg0 *quicksight.ListFoldersInput) (*quicksight.ListFoldersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFolders", arg0)
	ret0, _ := ret[0].(*quicksight.ListFoldersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFoldersPages mocks base method.
func (m *MockQuickSightAPI) ListFoldersPages(arg0 *quicksight.ListFoldersInput, arg1 func(*quicksight.ListFoldersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFoldersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFoldersPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListFoldersPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListFoldersInput, arg2 func(*quicksight.ListFoldersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFoldersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFoldersRequest mocks base method.
func (m *MockQuickSightAPI) ListFoldersRequest(arg0 *quicksight.ListFoldersInput) (*request.Request, *quicksight.ListFoldersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFoldersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListFoldersOutput)
	return ret0, ret1
}

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

// ListFoldersWithContext mocks base method.
func (m *MockQuickSightAPI) ListFoldersWithContext(arg0 aws.Context, arg1 *quicksight.ListFoldersInput, arg2 ...request.Option) (*quicksight.ListFoldersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFoldersWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListFoldersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGroupMemberships mocks base method.
func (m *MockQuickSightAPI) ListGroupMemberships(arg0 *quicksight.ListGroupMembershipsInput) (*quicksight.ListGroupMembershipsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGroupMemberships", arg0)
	ret0, _ := ret[0].(*quicksight.ListGroupMembershipsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGroupMembershipsPages mocks base method.
func (m *MockQuickSightAPI) ListGroupMembershipsPages(arg0 *quicksight.ListGroupMembershipsInput, arg1 func(*quicksight.ListGroupMembershipsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGroupMembershipsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGroupMembershipsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListGroupMembershipsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListGroupMembershipsInput, arg2 func(*quicksight.ListGroupMembershipsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupMembershipsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGroupMembershipsRequest mocks base method.
func (m *MockQuickSightAPI) ListGroupMembershipsRequest(arg0 *quicksight.ListGroupMembershipsInput) (*request.Request, *quicksight.ListGroupMembershipsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGroupMembershipsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListGroupMembershipsOutput)
	return ret0, ret1
}

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

// ListGroupMembershipsWithContext mocks base method.
func (m *MockQuickSightAPI) ListGroupMembershipsWithContext(arg0 aws.Context, arg1 *quicksight.ListGroupMembershipsInput, arg2 ...request.Option) (*quicksight.ListGroupMembershipsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupMembershipsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListGroupMembershipsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGroups mocks base method.
func (m *MockQuickSightAPI) ListGroups(arg0 *quicksight.ListGroupsInput) (*quicksight.ListGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGroups", arg0)
	ret0, _ := ret[0].(*quicksight.ListGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGroupsPages mocks base method.
func (m *MockQuickSightAPI) ListGroupsPages(arg0 *quicksight.ListGroupsInput, arg1 func(*quicksight.ListGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGroupsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListGroupsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListGroupsInput, arg2 func(*quicksight.ListGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGroupsRequest mocks base method.
func (m *MockQuickSightAPI) ListGroupsRequest(arg0 *quicksight.ListGroupsInput) (*request.Request, *quicksight.ListGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListGroupsOutput)
	return ret0, ret1
}

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

// ListGroupsWithContext mocks base method.
func (m *MockQuickSightAPI) ListGroupsWithContext(arg0 aws.Context, arg1 *quicksight.ListGroupsInput, arg2 ...request.Option) (*quicksight.ListGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIAMPolicyAssignments mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignments(arg0 *quicksight.ListIAMPolicyAssignmentsInput) (*quicksight.ListIAMPolicyAssignmentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignments", arg0)
	ret0, _ := ret[0].(*quicksight.ListIAMPolicyAssignmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIAMPolicyAssignmentsForUser mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsForUser(arg0 *quicksight.ListIAMPolicyAssignmentsForUserInput) (*quicksight.ListIAMPolicyAssignmentsForUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsForUser", arg0)
	ret0, _ := ret[0].(*quicksight.ListIAMPolicyAssignmentsForUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIAMPolicyAssignmentsForUserPages mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsForUserPages(arg0 *quicksight.ListIAMPolicyAssignmentsForUserInput, arg1 func(*quicksight.ListIAMPolicyAssignmentsForUserOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsForUserPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIAMPolicyAssignmentsForUserPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsForUserPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListIAMPolicyAssignmentsForUserInput, arg2 func(*quicksight.ListIAMPolicyAssignmentsForUserOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsForUserPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIAMPolicyAssignmentsForUserRequest mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsForUserRequest(arg0 *quicksight.ListIAMPolicyAssignmentsForUserInput) (*request.Request, *quicksight.ListIAMPolicyAssignmentsForUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsForUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListIAMPolicyAssignmentsForUserOutput)
	return ret0, ret1
}

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

// ListIAMPolicyAssignmentsForUserWithContext mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsForUserWithContext(arg0 aws.Context, arg1 *quicksight.ListIAMPolicyAssignmentsForUserInput, arg2 ...request.Option) (*quicksight.ListIAMPolicyAssignmentsForUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsForUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListIAMPolicyAssignmentsForUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIAMPolicyAssignmentsPages mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsPages(arg0 *quicksight.ListIAMPolicyAssignmentsInput, arg1 func(*quicksight.ListIAMPolicyAssignmentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIAMPolicyAssignmentsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListIAMPolicyAssignmentsInput, arg2 func(*quicksight.ListIAMPolicyAssignmentsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIAMPolicyAssignmentsRequest mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsRequest(arg0 *quicksight.ListIAMPolicyAssignmentsInput) (*request.Request, *quicksight.ListIAMPolicyAssignmentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListIAMPolicyAssignmentsOutput)
	return ret0, ret1
}

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

// ListIAMPolicyAssignmentsWithContext mocks base method.
func (m *MockQuickSightAPI) ListIAMPolicyAssignmentsWithContext(arg0 aws.Context, arg1 *quicksight.ListIAMPolicyAssignmentsInput, arg2 ...request.Option) (*quicksight.ListIAMPolicyAssignmentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIAMPolicyAssignmentsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListIAMPolicyAssignmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIdentityPropagationConfigs mocks base method.
func (m *MockQuickSightAPI) ListIdentityPropagationConfigs(arg0 *quicksight.ListIdentityPropagationConfigsInput) (*quicksight.ListIdentityPropagationConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityPropagationConfigs", arg0)
	ret0, _ := ret[0].(*quicksight.ListIdentityPropagationConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIdentityPropagationConfigsRequest mocks base method.
func (m *MockQuickSightAPI) ListIdentityPropagationConfigsRequest(arg0 *quicksight.ListIdentityPropagationConfigsInput) (*request.Request, *quicksight.ListIdentityPropagationConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityPropagationConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListIdentityPropagationConfigsOutput)
	return ret0, ret1
}

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

// ListIdentityPropagationConfigsWithContext mocks base method.
func (m *MockQuickSightAPI) ListIdentityPropagationConfigsWithContext(arg0 aws.Context, arg1 *quicksight.ListIdentityPropagationConfigsInput, arg2 ...request.Option) (*quicksight.ListIdentityPropagationConfigsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIdentityPropagationConfigsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListIdentityPropagationConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIngestions mocks base method.
func (m *MockQuickSightAPI) ListIngestions(arg0 *quicksight.ListIngestionsInput) (*quicksight.ListIngestionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIngestions", arg0)
	ret0, _ := ret[0].(*quicksight.ListIngestionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIngestionsPages mocks base method.
func (m *MockQuickSightAPI) ListIngestionsPages(arg0 *quicksight.ListIngestionsInput, arg1 func(*quicksight.ListIngestionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIngestionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIngestionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListIngestionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListIngestionsInput, arg2 func(*quicksight.ListIngestionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIngestionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIngestionsRequest mocks base method.
func (m *MockQuickSightAPI) ListIngestionsRequest(arg0 *quicksight.ListIngestionsInput) (*request.Request, *quicksight.ListIngestionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIngestionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListIngestionsOutput)
	return ret0, ret1
}

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

// ListIngestionsWithContext mocks base method.
func (m *MockQuickSightAPI) ListIngestionsWithContext(arg0 aws.Context, arg1 *quicksight.ListIngestionsInput, arg2 ...request.Option) (*quicksight.ListIngestionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIngestionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListIngestionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNamespaces mocks base method.
func (m *MockQuickSightAPI) ListNamespaces(arg0 *quicksight.ListNamespacesInput) (*quicksight.ListNamespacesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespaces", arg0)
	ret0, _ := ret[0].(*quicksight.ListNamespacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNamespacesPages mocks base method.
func (m *MockQuickSightAPI) ListNamespacesPages(arg0 *quicksight.ListNamespacesInput, arg1 func(*quicksight.ListNamespacesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespacesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListNamespacesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListNamespacesPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListNamespacesInput, arg2 func(*quicksight.ListNamespacesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNamespacesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListNamespacesRequest mocks base method.
func (m *MockQuickSightAPI) ListNamespacesRequest(arg0 *quicksight.ListNamespacesInput) (*request.Request, *quicksight.ListNamespacesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespacesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListNamespacesOutput)
	return ret0, ret1
}

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

// ListNamespacesWithContext mocks base method.
func (m *MockQuickSightAPI) ListNamespacesWithContext(arg0 aws.Context, arg1 *quicksight.ListNamespacesInput, arg2 ...request.Option) (*quicksight.ListNamespacesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNamespacesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListNamespacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRefreshSchedules mocks base method.
func (m *MockQuickSightAPI) ListRefreshSchedules(arg0 *quicksight.ListRefreshSchedulesInput) (*quicksight.ListRefreshSchedulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRefreshSchedules", arg0)
	ret0, _ := ret[0].(*quicksight.ListRefreshSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRefreshSchedulesRequest mocks base method.
func (m *MockQuickSightAPI) ListRefreshSchedulesRequest(arg0 *quicksight.ListRefreshSchedulesInput) (*request.Request, *quicksight.ListRefreshSchedulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRefreshSchedulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListRefreshSchedulesOutput)
	return ret0, ret1
}

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

// ListRefreshSchedulesWithContext mocks base method.
func (m *MockQuickSightAPI) ListRefreshSchedulesWithContext(arg0 aws.Context, arg1 *quicksight.ListRefreshSchedulesInput, arg2 ...request.Option) (*quicksight.ListRefreshSchedulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRefreshSchedulesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListRefreshSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRoleMemberships mocks base method.
func (m *MockQuickSightAPI) ListRoleMemberships(arg0 *quicksight.ListRoleMembershipsInput) (*quicksight.ListRoleMembershipsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRoleMemberships", arg0)
	ret0, _ := ret[0].(*quicksight.ListRoleMembershipsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRoleMembershipsPages mocks base method.
func (m *MockQuickSightAPI) ListRoleMembershipsPages(arg0 *quicksight.ListRoleMembershipsInput, arg1 func(*quicksight.ListRoleMembershipsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRoleMembershipsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListRoleMembershipsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListRoleMembershipsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListRoleMembershipsInput, arg2 func(*quicksight.ListRoleMembershipsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRoleMembershipsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListRoleMembershipsRequest mocks base method.
func (m *MockQuickSightAPI) ListRoleMembershipsRequest(arg0 *quicksight.ListRoleMembershipsInput) (*request.Request, *quicksight.ListRoleMembershipsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRoleMembershipsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListRoleMembershipsOutput)
	return ret0, ret1
}

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

// ListRoleMembershipsWithContext mocks base method.
func (m *MockQuickSightAPI) ListRoleMembershipsWithContext(arg0 aws.Context, arg1 *quicksight.ListRoleMembershipsInput, arg2 ...request.Option) (*quicksight.ListRoleMembershipsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRoleMembershipsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListRoleMembershipsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResource mocks base method.
func (m *MockQuickSightAPI) ListTagsForResource(arg0 *quicksight.ListTagsForResourceInput) (*quicksight.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*quicksight.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResourceRequest mocks base method.
func (m *MockQuickSightAPI) ListTagsForResourceRequest(arg0 *quicksight.ListTagsForResourceInput) (*request.Request, *quicksight.ListTagsForResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTagsForResourceOutput)
	return ret0, ret1
}

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

// ListTagsForResourceWithContext mocks base method.
func (m *MockQuickSightAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *quicksight.ListTagsForResourceInput, arg2 ...request.Option) (*quicksight.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplateAliases mocks base method.
func (m *MockQuickSightAPI) ListTemplateAliases(arg0 *quicksight.ListTemplateAliasesInput) (*quicksight.ListTemplateAliasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplateAliases", arg0)
	ret0, _ := ret[0].(*quicksight.ListTemplateAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplateAliasesPages mocks base method.
func (m *MockQuickSightAPI) ListTemplateAliasesPages(arg0 *quicksight.ListTemplateAliasesInput, arg1 func(*quicksight.ListTemplateAliasesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplateAliasesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTemplateAliasesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTemplateAliasesPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListTemplateAliasesInput, arg2 func(*quicksight.ListTemplateAliasesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplateAliasesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTemplateAliasesRequest mocks base method.
func (m *MockQuickSightAPI) ListTemplateAliasesRequest(arg0 *quicksight.ListTemplateAliasesInput) (*request.Request, *quicksight.ListTemplateAliasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplateAliasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTemplateAliasesOutput)
	return ret0, ret1
}

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

// ListTemplateAliasesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTemplateAliasesWithContext(arg0 aws.Context, arg1 *quicksight.ListTemplateAliasesInput, arg2 ...request.Option) (*quicksight.ListTemplateAliasesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplateAliasesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTemplateAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplateVersions mocks base method.
func (m *MockQuickSightAPI) ListTemplateVersions(arg0 *quicksight.ListTemplateVersionsInput) (*quicksight.ListTemplateVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplateVersions", arg0)
	ret0, _ := ret[0].(*quicksight.ListTemplateVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplateVersionsPages mocks base method.
func (m *MockQuickSightAPI) ListTemplateVersionsPages(arg0 *quicksight.ListTemplateVersionsInput, arg1 func(*quicksight.ListTemplateVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplateVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTemplateVersionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTemplateVersionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListTemplateVersionsInput, arg2 func(*quicksight.ListTemplateVersionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplateVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTemplateVersionsRequest mocks base method.
func (m *MockQuickSightAPI) ListTemplateVersionsRequest(arg0 *quicksight.ListTemplateVersionsInput) (*request.Request, *quicksight.ListTemplateVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplateVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTemplateVersionsOutput)
	return ret0, ret1
}

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

// ListTemplateVersionsWithContext mocks base method.
func (m *MockQuickSightAPI) ListTemplateVersionsWithContext(arg0 aws.Context, arg1 *quicksight.ListTemplateVersionsInput, arg2 ...request.Option) (*quicksight.ListTemplateVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplateVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTemplateVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplates mocks base method.
func (m *MockQuickSightAPI) ListTemplates(arg0 *quicksight.ListTemplatesInput) (*quicksight.ListTemplatesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplates", arg0)
	ret0, _ := ret[0].(*quicksight.ListTemplatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplatesPages mocks base method.
func (m *MockQuickSightAPI) ListTemplatesPages(arg0 *quicksight.ListTemplatesInput, arg1 func(*quicksight.ListTemplatesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplatesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTemplatesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTemplatesPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListTemplatesInput, arg2 func(*quicksight.ListTemplatesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplatesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTemplatesRequest mocks base method.
func (m *MockQuickSightAPI) ListTemplatesRequest(arg0 *quicksight.ListTemplatesInput) (*request.Request, *quicksight.ListTemplatesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplatesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTemplatesOutput)
	return ret0, ret1
}

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

// ListTemplatesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTemplatesWithContext(arg0 aws.Context, arg1 *quicksight.ListTemplatesInput, arg2 ...request.Option) (*quicksight.ListTemplatesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplatesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTemplatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListThemeAliases mocks base method.
func (m *MockQuickSightAPI) ListThemeAliases(arg0 *quicksight.ListThemeAliasesInput) (*quicksight.ListThemeAliasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemeAliases", arg0)
	ret0, _ := ret[0].(*quicksight.ListThemeAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListThemeAliasesRequest mocks base method.
func (m *MockQuickSightAPI) ListThemeAliasesRequest(arg0 *quicksight.ListThemeAliasesInput) (*request.Request, *quicksight.ListThemeAliasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemeAliasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListThemeAliasesOutput)
	return ret0, ret1
}

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

// ListThemeAliasesWithContext mocks base method.
func (m *MockQuickSightAPI) ListThemeAliasesWithContext(arg0 aws.Context, arg1 *quicksight.ListThemeAliasesInput, arg2 ...request.Option) (*quicksight.ListThemeAliasesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemeAliasesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListThemeAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListThemeVersions mocks base method.
func (m *MockQuickSightAPI) ListThemeVersions(arg0 *quicksight.ListThemeVersionsInput) (*quicksight.ListThemeVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemeVersions", arg0)
	ret0, _ := ret[0].(*quicksight.ListThemeVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListThemeVersionsPages mocks base method.
func (m *MockQuickSightAPI) ListThemeVersionsPages(arg0 *quicksight.ListThemeVersionsInput, arg1 func(*quicksight.ListThemeVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemeVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListThemeVersionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListThemeVersionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListThemeVersionsInput, arg2 func(*quicksight.ListThemeVersionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemeVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListThemeVersionsRequest mocks base method.
func (m *MockQuickSightAPI) ListThemeVersionsRequest(arg0 *quicksight.ListThemeVersionsInput) (*request.Request, *quicksight.ListThemeVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemeVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListThemeVersionsOutput)
	return ret0, ret1
}

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

// ListThemeVersionsWithContext mocks base method.
func (m *MockQuickSightAPI) ListThemeVersionsWithContext(arg0 aws.Context, arg1 *quicksight.ListThemeVersionsInput, arg2 ...request.Option) (*quicksight.ListThemeVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemeVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListThemeVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListThemes mocks base method.
func (m *MockQuickSightAPI) ListThemes(arg0 *quicksight.ListThemesInput) (*quicksight.ListThemesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemes", arg0)
	ret0, _ := ret[0].(*quicksight.ListThemesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListThemesPages mocks base method.
func (m *MockQuickSightAPI) ListThemesPages(arg0 *quicksight.ListThemesInput, arg1 func(*quicksight.ListThemesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListThemesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListThemesPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListThemesInput, arg2 func(*quicksight.ListThemesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListThemesRequest mocks base method.
func (m *MockQuickSightAPI) ListThemesRequest(arg0 *quicksight.ListThemesInput) (*request.Request, *quicksight.ListThemesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListThemesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListThemesOutput)
	return ret0, ret1
}

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

// ListThemesWithContext mocks base method.
func (m *MockQuickSightAPI) ListThemesWithContext(arg0 aws.Context, arg1 *quicksight.ListThemesInput, arg2 ...request.Option) (*quicksight.ListThemesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListThemesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopicRefreshSchedules mocks base method.
func (m *MockQuickSightAPI) ListTopicRefreshSchedules(arg0 *quicksight.ListTopicRefreshSchedulesInput) (*quicksight.ListTopicRefreshSchedulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopicRefreshSchedules", arg0)
	ret0, _ := ret[0].(*quicksight.ListTopicRefreshSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopicRefreshSchedulesRequest mocks base method.
func (m *MockQuickSightAPI) ListTopicRefreshSchedulesRequest(arg0 *quicksight.ListTopicRefreshSchedulesInput) (*request.Request, *quicksight.ListTopicRefreshSchedulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopicRefreshSchedulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTopicRefreshSchedulesOutput)
	return ret0, ret1
}

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

// ListTopicRefreshSchedulesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTopicRefreshSchedulesWithContext(arg0 aws.Context, arg1 *quicksight.ListTopicRefreshSchedulesInput, arg2 ...request.Option) (*quicksight.ListTopicRefreshSchedulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicRefreshSchedulesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTopicRefreshSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopicReviewedAnswers mocks base method.
func (m *MockQuickSightAPI) ListTopicReviewedAnswers(arg0 *quicksight.ListTopicReviewedAnswersInput) (*quicksight.ListTopicReviewedAnswersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopicReviewedAnswers", arg0)
	ret0, _ := ret[0].(*quicksight.ListTopicReviewedAnswersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopicReviewedAnswersRequest mocks base method.
func (m *MockQuickSightAPI) ListTopicReviewedAnswersRequest(arg0 *quicksight.ListTopicReviewedAnswersInput) (*request.Request, *quicksight.ListTopicReviewedAnswersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopicReviewedAnswersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTopicReviewedAnswersOutput)
	return ret0, ret1
}

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

// ListTopicReviewedAnswersWithContext mocks base method.
func (m *MockQuickSightAPI) ListTopicReviewedAnswersWithContext(arg0 aws.Context, arg1 *quicksight.ListTopicReviewedAnswersInput, arg2 ...request.Option) (*quicksight.ListTopicReviewedAnswersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicReviewedAnswersWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTopicReviewedAnswersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopics mocks base method.
func (m *MockQuickSightAPI) ListTopics(arg0 *quicksight.ListTopicsInput) (*quicksight.ListTopicsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopics", arg0)
	ret0, _ := ret[0].(*quicksight.ListTopicsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopicsPages mocks base method.
func (m *MockQuickSightAPI) ListTopicsPages(arg0 *quicksight.ListTopicsInput, arg1 func(*quicksight.ListTopicsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopicsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTopicsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListTopicsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListTopicsInput, arg2 func(*quicksight.ListTopicsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTopicsRequest mocks base method.
func (m *MockQuickSightAPI) ListTopicsRequest(arg0 *quicksight.ListTopicsInput) (*request.Request, *quicksight.ListTopicsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopicsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListTopicsOutput)
	return ret0, ret1
}

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

// ListTopicsWithContext mocks base method.
func (m *MockQuickSightAPI) ListTopicsWithContext(arg0 aws.Context, arg1 *quicksight.ListTopicsInput, arg2 ...request.Option) (*quicksight.ListTopicsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTopicsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserGroups mocks base method.
func (m *MockQuickSightAPI) ListUserGroups(arg0 *quicksight.ListUserGroupsInput) (*quicksight.ListUserGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserGroups", arg0)
	ret0, _ := ret[0].(*quicksight.ListUserGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserGroupsPages mocks base method.
func (m *MockQuickSightAPI) ListUserGroupsPages(arg0 *quicksight.ListUserGroupsInput, arg1 func(*quicksight.ListUserGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUserGroupsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListUserGroupsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListUserGroupsInput, arg2 func(*quicksight.ListUserGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUserGroupsRequest mocks base method.
func (m *MockQuickSightAPI) ListUserGroupsRequest(arg0 *quicksight.ListUserGroupsInput) (*request.Request, *quicksight.ListUserGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListUserGroupsOutput)
	return ret0, ret1
}

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

// ListUserGroupsWithContext mocks base method.
func (m *MockQuickSightAPI) ListUserGroupsWithContext(arg0 aws.Context, arg1 *quicksight.ListUserGroupsInput, arg2 ...request.Option) (*quicksight.ListUserGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListUserGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUsers mocks base method.
func (m *MockQuickSightAPI) ListUsers(arg0 *quicksight.ListUsersInput) (*quicksight.ListUsersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUsers", arg0)
	ret0, _ := ret[0].(*quicksight.ListUsersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUsersPages mocks base method.
func (m *MockQuickSightAPI) ListUsersPages(arg0 *quicksight.ListUsersInput, arg1 func(*quicksight.ListUsersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUsersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUsersPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListUsersPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListUsersInput, arg2 func(*quicksight.ListUsersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUsersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUsersRequest mocks base method.
func (m *MockQuickSightAPI) ListUsersRequest(arg0 *quicksight.ListUsersInput) (*request.Request, *quicksight.ListUsersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUsersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListUsersOutput)
	return ret0, ret1
}

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

// ListUsersWithContext mocks base method.
func (m *MockQuickSightAPI) ListUsersWithContext(arg0 aws.Context, arg1 *quicksight.ListUsersInput, arg2 ...request.Option) (*quicksight.ListUsersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUsersWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListUsersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVPCConnections mocks base method.
func (m *MockQuickSightAPI) ListVPCConnections(arg0 *quicksight.ListVPCConnectionsInput) (*quicksight.ListVPCConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVPCConnections", arg0)
	ret0, _ := ret[0].(*quicksight.ListVPCConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVPCConnectionsPages mocks base method.
func (m *MockQuickSightAPI) ListVPCConnectionsPages(arg0 *quicksight.ListVPCConnectionsInput, arg1 func(*quicksight.ListVPCConnectionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVPCConnectionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListVPCConnectionsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) ListVPCConnectionsPagesWithContext(arg0 aws.Context, arg1 *quicksight.ListVPCConnectionsInput, arg2 func(*quicksight.ListVPCConnectionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVPCConnectionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListVPCConnectionsRequest mocks base method.
func (m *MockQuickSightAPI) ListVPCConnectionsRequest(arg0 *quicksight.ListVPCConnectionsInput) (*request.Request, *quicksight.ListVPCConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVPCConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.ListVPCConnectionsOutput)
	return ret0, ret1
}

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

// ListVPCConnectionsWithContext mocks base method.
func (m *MockQuickSightAPI) ListVPCConnectionsWithContext(arg0 aws.Context, arg1 *quicksight.ListVPCConnectionsInput, arg2 ...request.Option) (*quicksight.ListVPCConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVPCConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.ListVPCConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutDataSetRefreshProperties mocks base method.
func (m *MockQuickSightAPI) PutDataSetRefreshProperties(arg0 *quicksight.PutDataSetRefreshPropertiesInput) (*quicksight.PutDataSetRefreshPropertiesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutDataSetRefreshProperties", arg0)
	ret0, _ := ret[0].(*quicksight.PutDataSetRefreshPropertiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutDataSetRefreshPropertiesRequest mocks base method.
func (m *MockQuickSightAPI) PutDataSetRefreshPropertiesRequest(arg0 *quicksight.PutDataSetRefreshPropertiesInput) (*request.Request, *quicksight.PutDataSetRefreshPropertiesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutDataSetRefreshPropertiesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.PutDataSetRefreshPropertiesOutput)
	return ret0, ret1
}

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

// PutDataSetRefreshPropertiesWithContext mocks base method.
func (m *MockQuickSightAPI) PutDataSetRefreshPropertiesWithContext(arg0 aws.Context, arg1 *quicksight.PutDataSetRefreshPropertiesInput, arg2 ...request.Option) (*quicksight.PutDataSetRefreshPropertiesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutDataSetRefreshPropertiesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.PutDataSetRefreshPropertiesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterUser mocks base method.
func (m *MockQuickSightAPI) RegisterUser(arg0 *quicksight.RegisterUserInput) (*quicksight.RegisterUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterUser", arg0)
	ret0, _ := ret[0].(*quicksight.RegisterUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterUserRequest mocks base method.
func (m *MockQuickSightAPI) RegisterUserRequest(arg0 *quicksight.RegisterUserInput) (*request.Request, *quicksight.RegisterUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.RegisterUserOutput)
	return ret0, ret1
}

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

// RegisterUserWithContext mocks base method.
func (m *MockQuickSightAPI) RegisterUserWithContext(arg0 aws.Context, arg1 *quicksight.RegisterUserInput, arg2 ...request.Option) (*quicksight.RegisterUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.RegisterUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreAnalysis mocks base method.
func (m *MockQuickSightAPI) RestoreAnalysis(arg0 *quicksight.RestoreAnalysisInput) (*quicksight.RestoreAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreAnalysis", arg0)
	ret0, _ := ret[0].(*quicksight.RestoreAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreAnalysisRequest mocks base method.
func (m *MockQuickSightAPI) RestoreAnalysisRequest(arg0 *quicksight.RestoreAnalysisInput) (*request.Request, *quicksight.RestoreAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.RestoreAnalysisOutput)
	return ret0, ret1
}

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

// RestoreAnalysisWithContext mocks base method.
func (m *MockQuickSightAPI) RestoreAnalysisWithContext(arg0 aws.Context, arg1 *quicksight.RestoreAnalysisInput, arg2 ...request.Option) (*quicksight.RestoreAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.RestoreAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchAnalyses mocks base method.
func (m *MockQuickSightAPI) SearchAnalyses(arg0 *quicksight.SearchAnalysesInput) (*quicksight.SearchAnalysesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchAnalyses", arg0)
	ret0, _ := ret[0].(*quicksight.SearchAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchAnalysesPages mocks base method.
func (m *MockQuickSightAPI) SearchAnalysesPages(arg0 *quicksight.SearchAnalysesInput, arg1 func(*quicksight.SearchAnalysesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchAnalysesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchAnalysesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchAnalysesPagesWithContext(arg0 aws.Context, arg1 *quicksight.SearchAnalysesInput, arg2 func(*quicksight.SearchAnalysesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchAnalysesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchAnalysesRequest mocks base method.
func (m *MockQuickSightAPI) SearchAnalysesRequest(arg0 *quicksight.SearchAnalysesInput) (*request.Request, *quicksight.SearchAnalysesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchAnalysesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.SearchAnalysesOutput)
	return ret0, ret1
}

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

// SearchAnalysesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchAnalysesWithContext(arg0 aws.Context, arg1 *quicksight.SearchAnalysesInput, arg2 ...request.Option) (*quicksight.SearchAnalysesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchAnalysesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDashboards mocks base method.
func (m *MockQuickSightAPI) SearchDashboards(arg0 *quicksight.SearchDashboardsInput) (*quicksight.SearchDashboardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDashboards", arg0)
	ret0, _ := ret[0].(*quicksight.SearchDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDashboardsPages mocks base method.
func (m *MockQuickSightAPI) SearchDashboardsPages(arg0 *quicksight.SearchDashboardsInput, arg1 func(*quicksight.SearchDashboardsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDashboardsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchDashboardsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchDashboardsPagesWithContext(arg0 aws.Context, arg1 *quicksight.SearchDashboardsInput, arg2 func(*quicksight.SearchDashboardsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDashboardsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchDashboardsRequest mocks base method.
func (m *MockQuickSightAPI) SearchDashboardsRequest(arg0 *quicksight.SearchDashboardsInput) (*request.Request, *quicksight.SearchDashboardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDashboardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.SearchDashboardsOutput)
	return ret0, ret1
}

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

// SearchDashboardsWithContext mocks base method.
func (m *MockQuickSightAPI) SearchDashboardsWithContext(arg0 aws.Context, arg1 *quicksight.SearchDashboardsInput, arg2 ...request.Option) (*quicksight.SearchDashboardsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDashboardsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDataSets mocks base method.
func (m *MockQuickSightAPI) SearchDataSets(arg0 *quicksight.SearchDataSetsInput) (*quicksight.SearchDataSetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDataSets", arg0)
	ret0, _ := ret[0].(*quicksight.SearchDataSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDataSetsPages mocks base method.
func (m *MockQuickSightAPI) SearchDataSetsPages(arg0 *quicksight.SearchDataSetsInput, arg1 func(*quicksight.SearchDataSetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDataSetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchDataSetsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchDataSetsPagesWithContext(arg0 aws.Context, arg1 *quicksight.SearchDataSetsInput, arg2 func(*quicksight.SearchDataSetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDataSetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchDataSetsRequest mocks base method.
func (m *MockQuickSightAPI) SearchDataSetsRequest(arg0 *quicksight.SearchDataSetsInput) (*request.Request, *quicksight.SearchDataSetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDataSetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.SearchDataSetsOutput)
	return ret0, ret1
}

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

// SearchDataSetsWithContext mocks base method.
func (m *MockQuickSightAPI) SearchDataSetsWithContext(arg0 aws.Context, arg1 *quicksight.SearchDataSetsInput, arg2 ...request.Option) (*quicksight.SearchDataSetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDataSetsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchDataSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDataSources mocks base method.
func (m *MockQuickSightAPI) SearchDataSources(arg0 *quicksight.SearchDataSourcesInput) (*quicksight.SearchDataSourcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDataSources", arg0)
	ret0, _ := ret[0].(*quicksight.SearchDataSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDataSourcesPages mocks base method.
func (m *MockQuickSightAPI) SearchDataSourcesPages(arg0 *quicksight.SearchDataSourcesInput, arg1 func(*quicksight.SearchDataSourcesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDataSourcesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchDataSourcesPagesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchDataSourcesPagesWithContext(arg0 aws.Context, arg1 *quicksight.SearchDataSourcesInput, arg2 func(*quicksight.SearchDataSourcesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDataSourcesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchDataSourcesRequest mocks base method.
func (m *MockQuickSightAPI) SearchDataSourcesRequest(arg0 *quicksight.SearchDataSourcesInput) (*request.Request, *quicksight.SearchDataSourcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDataSourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.SearchDataSourcesOutput)
	return ret0, ret1
}

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

// SearchDataSourcesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchDataSourcesWithContext(arg0 aws.Context, arg1 *quicksight.SearchDataSourcesInput, arg2 ...request.Option) (*quicksight.SearchDataSourcesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDataSourcesWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchDataSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchFolders mocks base method.
func (m *MockQuickSightAPI) SearchFolders(arg0 *quicksight.SearchFoldersInput) (*quicksight.SearchFoldersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchFolders", arg0)
	ret0, _ := ret[0].(*quicksight.SearchFoldersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchFoldersPages mocks base method.
func (m *MockQuickSightAPI) SearchFoldersPages(arg0 *quicksight.SearchFoldersInput, arg1 func(*quicksight.SearchFoldersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchFoldersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchFoldersPagesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchFoldersPagesWithContext(arg0 aws.Context, arg1 *quicksight.SearchFoldersInput, arg2 func(*quicksight.SearchFoldersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchFoldersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchFoldersRequest mocks base method.
func (m *MockQuickSightAPI) SearchFoldersRequest(arg0 *quicksight.SearchFoldersInput) (*request.Request, *quicksight.SearchFoldersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchFoldersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.SearchFoldersOutput)
	return ret0, ret1
}

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

// SearchFoldersWithContext mocks base method.
func (m *MockQuickSightAPI) SearchFoldersWithContext(arg0 aws.Context, arg1 *quicksight.SearchFoldersInput, arg2 ...request.Option) (*quicksight.SearchFoldersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchFoldersWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchFoldersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchGroups mocks base method.
func (m *MockQuickSightAPI) SearchGroups(arg0 *quicksight.SearchGroupsInput) (*quicksight.SearchGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchGroups", arg0)
	ret0, _ := ret[0].(*quicksight.SearchGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchGroupsPages mocks base method.
func (m *MockQuickSightAPI) SearchGroupsPages(arg0 *quicksight.SearchGroupsInput, arg1 func(*quicksight.SearchGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchGroupsPagesWithContext mocks base method.
func (m *MockQuickSightAPI) SearchGroupsPagesWithContext(arg0 aws.Context, arg1 *quicksight.SearchGroupsInput, arg2 func(*quicksight.SearchGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchGroupsRequest mocks base method.
func (m *MockQuickSightAPI) SearchGroupsRequest(arg0 *quicksight.SearchGroupsInput) (*request.Request, *quicksight.SearchGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.SearchGroupsOutput)
	return ret0, ret1
}

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

// SearchGroupsWithContext mocks base method.
func (m *MockQuickSightAPI) SearchGroupsWithContext(arg0 aws.Context, arg1 *quicksight.SearchGroupsInput, arg2 ...request.Option) (*quicksight.SearchGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartAssetBundleExportJob mocks base method.
func (m *MockQuickSightAPI) StartAssetBundleExportJob(arg0 *quicksight.StartAssetBundleExportJobInput) (*quicksight.StartAssetBundleExportJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartAssetBundleExportJob", arg0)
	ret0, _ := ret[0].(*quicksight.StartAssetBundleExportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartAssetBundleExportJobRequest mocks base method.
func (m *MockQuickSightAPI) StartAssetBundleExportJobRequest(arg0 *quicksight.StartAssetBundleExportJobInput) (*request.Request, *quicksight.StartAssetBundleExportJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartAssetBundleExportJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.StartAssetBundleExportJobOutput)
	return ret0, ret1
}

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

// StartAssetBundleExportJobWithContext mocks base method.
func (m *MockQuickSightAPI) StartAssetBundleExportJobWithContext(arg0 aws.Context, arg1 *quicksight.StartAssetBundleExportJobInput, arg2 ...request.Option) (*quicksight.StartAssetBundleExportJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartAssetBundleExportJobWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.StartAssetBundleExportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartAssetBundleImportJob mocks base method.
func (m *MockQuickSightAPI) StartAssetBundleImportJob(arg0 *quicksight.StartAssetBundleImportJobInput) (*quicksight.StartAssetBundleImportJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartAssetBundleImportJob", arg0)
	ret0, _ := ret[0].(*quicksight.StartAssetBundleImportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartAssetBundleImportJobRequest mocks base method.
func (m *MockQuickSightAPI) StartAssetBundleImportJobRequest(arg0 *quicksight.StartAssetBundleImportJobInput) (*request.Request, *quicksight.StartAssetBundleImportJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartAssetBundleImportJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.StartAssetBundleImportJobOutput)
	return ret0, ret1
}

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

// StartAssetBundleImportJobWithContext mocks base method.
func (m *MockQuickSightAPI) StartAssetBundleImportJobWithContext(arg0 aws.Context, arg1 *quicksight.StartAssetBundleImportJobInput, arg2 ...request.Option) (*quicksight.StartAssetBundleImportJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartAssetBundleImportJobWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.StartAssetBundleImportJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartDashboardSnapshotJob mocks base method.
func (m *MockQuickSightAPI) StartDashboardSnapshotJob(arg0 *quicksight.StartDashboardSnapshotJobInput) (*quicksight.StartDashboardSnapshotJobOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartDashboardSnapshotJob", arg0)
	ret0, _ := ret[0].(*quicksight.StartDashboardSnapshotJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartDashboardSnapshotJobRequest mocks base method.
func (m *MockQuickSightAPI) StartDashboardSnapshotJobRequest(arg0 *quicksight.StartDashboardSnapshotJobInput) (*request.Request, *quicksight.StartDashboardSnapshotJobOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartDashboardSnapshotJobRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.StartDashboardSnapshotJobOutput)
	return ret0, ret1
}

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

// StartDashboardSnapshotJobWithContext mocks base method.
func (m *MockQuickSightAPI) StartDashboardSnapshotJobWithContext(arg0 aws.Context, arg1 *quicksight.StartDashboardSnapshotJobInput, arg2 ...request.Option) (*quicksight.StartDashboardSnapshotJobOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartDashboardSnapshotJobWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.StartDashboardSnapshotJobOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateAccountCustomization mocks base method.
func (m *MockQuickSightAPI) UpdateAccountCustomization(arg0 *quicksight.UpdateAccountCustomizationInput) (*quicksight.UpdateAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountCustomization", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAccountCustomizationRequest mocks base method.
func (m *MockQuickSightAPI) UpdateAccountCustomizationRequest(arg0 *quicksight.UpdateAccountCustomizationInput) (*request.Request, *quicksight.UpdateAccountCustomizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountCustomizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateAccountCustomizationOutput)
	return ret0, ret1
}

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

// UpdateAccountCustomizationWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateAccountCustomizationWithContext(arg0 aws.Context, arg1 *quicksight.UpdateAccountCustomizationInput, arg2 ...request.Option) (*quicksight.UpdateAccountCustomizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAccountCustomizationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateAccountCustomizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAccountSettings mocks base method.
func (m *MockQuickSightAPI) UpdateAccountSettings(arg0 *quicksight.UpdateAccountSettingsInput) (*quicksight.UpdateAccountSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountSettings", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateAccountSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAccountSettingsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateAccountSettingsRequest(arg0 *quicksight.UpdateAccountSettingsInput) (*request.Request, *quicksight.UpdateAccountSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateAccountSettingsOutput)
	return ret0, ret1
}

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

// UpdateAccountSettingsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateAccountSettingsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateAccountSettingsInput, arg2 ...request.Option) (*quicksight.UpdateAccountSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAccountSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateAccountSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAnalysis mocks base method.
func (m *MockQuickSightAPI) UpdateAnalysis(arg0 *quicksight.UpdateAnalysisInput) (*quicksight.UpdateAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAnalysis", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAnalysisPermissions mocks base method.
func (m *MockQuickSightAPI) UpdateAnalysisPermissions(arg0 *quicksight.UpdateAnalysisPermissionsInput) (*quicksight.UpdateAnalysisPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAnalysisPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateAnalysisPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAnalysisPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateAnalysisPermissionsRequest(arg0 *quicksight.UpdateAnalysisPermissionsInput) (*request.Request, *quicksight.UpdateAnalysisPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAnalysisPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateAnalysisPermissionsOutput)
	return ret0, ret1
}

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

// UpdateAnalysisPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateAnalysisPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateAnalysisPermissionsInput, arg2 ...request.Option) (*quicksight.UpdateAnalysisPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAnalysisPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateAnalysisPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAnalysisRequest mocks base method.
func (m *MockQuickSightAPI) UpdateAnalysisRequest(arg0 *quicksight.UpdateAnalysisInput) (*request.Request, *quicksight.UpdateAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateAnalysisOutput)
	return ret0, ret1
}

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

// UpdateAnalysisWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateAnalysisWithContext(arg0 aws.Context, arg1 *quicksight.UpdateAnalysisInput, arg2 ...request.Option) (*quicksight.UpdateAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboard mocks base method.
func (m *MockQuickSightAPI) UpdateDashboard(arg0 *quicksight.UpdateDashboardInput) (*quicksight.UpdateDashboardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboard", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardLinks mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardLinks(arg0 *quicksight.UpdateDashboardLinksInput) (*quicksight.UpdateDashboardLinksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardLinks", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardLinksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardLinksRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardLinksRequest(arg0 *quicksight.UpdateDashboardLinksInput) (*request.Request, *quicksight.UpdateDashboardLinksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardLinksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDashboardLinksOutput)
	return ret0, ret1
}

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

// UpdateDashboardLinksWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardLinksWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDashboardLinksInput, arg2 ...request.Option) (*quicksight.UpdateDashboardLinksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDashboardLinksWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardLinksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardPermissions mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardPermissions(arg0 *quicksight.UpdateDashboardPermissionsInput) (*quicksight.UpdateDashboardPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardPermissionsRequest(arg0 *quicksight.UpdateDashboardPermissionsInput) (*request.Request, *quicksight.UpdateDashboardPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDashboardPermissionsOutput)
	return ret0, ret1
}

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

// UpdateDashboardPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDashboardPermissionsInput, arg2 ...request.Option) (*quicksight.UpdateDashboardPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDashboardPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardPublishedVersion mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardPublishedVersion(arg0 *quicksight.UpdateDashboardPublishedVersionInput) (*quicksight.UpdateDashboardPublishedVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardPublishedVersion", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardPublishedVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardPublishedVersionRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardPublishedVersionRequest(arg0 *quicksight.UpdateDashboardPublishedVersionInput) (*request.Request, *quicksight.UpdateDashboardPublishedVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardPublishedVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDashboardPublishedVersionOutput)
	return ret0, ret1
}

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

// UpdateDashboardPublishedVersionWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardPublishedVersionWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDashboardPublishedVersionInput, arg2 ...request.Option) (*quicksight.UpdateDashboardPublishedVersionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDashboardPublishedVersionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardPublishedVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDashboardRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardRequest(arg0 *quicksight.UpdateDashboardInput) (*request.Request, *quicksight.UpdateDashboardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDashboardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDashboardOutput)
	return ret0, ret1
}

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

// UpdateDashboardWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDashboardWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDashboardInput, arg2 ...request.Option) (*quicksight.UpdateDashboardOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDashboardWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDashboardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSet mocks base method.
func (m *MockQuickSightAPI) UpdateDataSet(arg0 *quicksight.UpdateDataSetInput) (*quicksight.UpdateDataSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSet", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSetPermissions mocks base method.
func (m *MockQuickSightAPI) UpdateDataSetPermissions(arg0 *quicksight.UpdateDataSetPermissionsInput) (*quicksight.UpdateDataSetPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSetPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDataSetPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSetPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDataSetPermissionsRequest(arg0 *quicksight.UpdateDataSetPermissionsInput) (*request.Request, *quicksight.UpdateDataSetPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSetPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDataSetPermissionsOutput)
	return ret0, ret1
}

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

// UpdateDataSetPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDataSetPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDataSetPermissionsInput, arg2 ...request.Option) (*quicksight.UpdateDataSetPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDataSetPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDataSetPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSetRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDataSetRequest(arg0 *quicksight.UpdateDataSetInput) (*request.Request, *quicksight.UpdateDataSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDataSetOutput)
	return ret0, ret1
}

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

// UpdateDataSetWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDataSetWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDataSetInput, arg2 ...request.Option) (*quicksight.UpdateDataSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDataSetWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDataSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSource mocks base method.
func (m *MockQuickSightAPI) UpdateDataSource(arg0 *quicksight.UpdateDataSourceInput) (*quicksight.UpdateDataSourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSource", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSourcePermissions mocks base method.
func (m *MockQuickSightAPI) UpdateDataSourcePermissions(arg0 *quicksight.UpdateDataSourcePermissionsInput) (*quicksight.UpdateDataSourcePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSourcePermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateDataSourcePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSourcePermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDataSourcePermissionsRequest(arg0 *quicksight.UpdateDataSourcePermissionsInput) (*request.Request, *quicksight.UpdateDataSourcePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSourcePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDataSourcePermissionsOutput)
	return ret0, ret1
}

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

// UpdateDataSourcePermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDataSourcePermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDataSourcePermissionsInput, arg2 ...request.Option) (*quicksight.UpdateDataSourcePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDataSourcePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDataSourcePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataSourceRequest mocks base method.
func (m *MockQuickSightAPI) UpdateDataSourceRequest(arg0 *quicksight.UpdateDataSourceInput) (*request.Request, *quicksight.UpdateDataSourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataSourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateDataSourceOutput)
	return ret0, ret1
}

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

// UpdateDataSourceWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateDataSourceWithContext(arg0 aws.Context, arg1 *quicksight.UpdateDataSourceInput, arg2 ...request.Option) (*quicksight.UpdateDataSourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDataSourceWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateDataSourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFolder mocks base method.
func (m *MockQuickSightAPI) UpdateFolder(arg0 *quicksight.UpdateFolderInput) (*quicksight.UpdateFolderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFolder", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFolderPermissions mocks base method.
func (m *MockQuickSightAPI) UpdateFolderPermissions(arg0 *quicksight.UpdateFolderPermissionsInput) (*quicksight.UpdateFolderPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFolderPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateFolderPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFolderPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateFolderPermissionsRequest(arg0 *quicksight.UpdateFolderPermissionsInput) (*request.Request, *quicksight.UpdateFolderPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFolderPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateFolderPermissionsOutput)
	return ret0, ret1
}

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

// UpdateFolderPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateFolderPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateFolderPermissionsInput, arg2 ...request.Option) (*quicksight.UpdateFolderPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFolderPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateFolderPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFolderRequest mocks base method.
func (m *MockQuickSightAPI) UpdateFolderRequest(arg0 *quicksight.UpdateFolderInput) (*request.Request, *quicksight.UpdateFolderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFolderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateFolderOutput)
	return ret0, ret1
}

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

// UpdateFolderWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateFolderWithContext(arg0 aws.Context, arg1 *quicksight.UpdateFolderInput, arg2 ...request.Option) (*quicksight.UpdateFolderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFolderWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateFolderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGroup mocks base method.
func (m *MockQuickSightAPI) UpdateGroup(arg0 *quicksight.UpdateGroupInput) (*quicksight.UpdateGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroup", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGroupRequest mocks base method.
func (m *MockQuickSightAPI) UpdateGroupRequest(arg0 *quicksight.UpdateGroupInput) (*request.Request, *quicksight.UpdateGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateGroupOutput)
	return ret0, ret1
}

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

// UpdateGroupWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateGroupWithContext(arg0 aws.Context, arg1 *quicksight.UpdateGroupInput, arg2 ...request.Option) (*quicksight.UpdateGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGroupWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIAMPolicyAssignment mocks base method.
func (m *MockQuickSightAPI) UpdateIAMPolicyAssignment(arg0 *quicksight.UpdateIAMPolicyAssignmentInput) (*quicksight.UpdateIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIAMPolicyAssignment", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIAMPolicyAssignmentRequest mocks base method.
func (m *MockQuickSightAPI) UpdateIAMPolicyAssignmentRequest(arg0 *quicksight.UpdateIAMPolicyAssignmentInput) (*request.Request, *quicksight.UpdateIAMPolicyAssignmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIAMPolicyAssignmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateIAMPolicyAssignmentOutput)
	return ret0, ret1
}

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

// UpdateIAMPolicyAssignmentWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateIAMPolicyAssignmentWithContext(arg0 aws.Context, arg1 *quicksight.UpdateIAMPolicyAssignmentInput, arg2 ...request.Option) (*quicksight.UpdateIAMPolicyAssignmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateIAMPolicyAssignmentWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateIAMPolicyAssignmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIdentityPropagationConfig mocks base method.
func (m *MockQuickSightAPI) UpdateIdentityPropagationConfig(arg0 *quicksight.UpdateIdentityPropagationConfigInput) (*quicksight.UpdateIdentityPropagationConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIdentityPropagationConfig", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateIdentityPropagationConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIdentityPropagationConfigRequest mocks base method.
func (m *MockQuickSightAPI) UpdateIdentityPropagationConfigRequest(arg0 *quicksight.UpdateIdentityPropagationConfigInput) (*request.Request, *quicksight.UpdateIdentityPropagationConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIdentityPropagationConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateIdentityPropagationConfigOutput)
	return ret0, ret1
}

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

// UpdateIdentityPropagationConfigWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateIdentityPropagationConfigWithContext(arg0 aws.Context, arg1 *quicksight.UpdateIdentityPropagationConfigInput, arg2 ...request.Option) (*quicksight.UpdateIdentityPropagationConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateIdentityPropagationConfigWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateIdentityPropagationConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIpRestriction mocks base method.
func (m *MockQuickSightAPI) UpdateIpRestriction(arg0 *quicksight.UpdateIpRestrictionInput) (*quicksight.UpdateIpRestrictionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIpRestriction", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateIpRestrictionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIpRestrictionRequest mocks base method.
func (m *MockQuickSightAPI) UpdateIpRestrictionRequest(arg0 *quicksight.UpdateIpRestrictionInput) (*request.Request, *quicksight.UpdateIpRestrictionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIpRestrictionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateIpRestrictionOutput)
	return ret0, ret1
}

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

// UpdateIpRestrictionWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateIpRestrictionWithContext(arg0 aws.Context, arg1 *quicksight.UpdateIpRestrictionInput, arg2 ...request.Option) (*quicksight.UpdateIpRestrictionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateIpRestrictionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateIpRestrictionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateKeyRegistration mocks base method.
func (m *MockQuickSightAPI) UpdateKeyRegistration(arg0 *quicksight.UpdateKeyRegistrationInput) (*quicksight.UpdateKeyRegistrationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKeyRegistration", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateKeyRegistrationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateKeyRegistrationRequest mocks base method.
func (m *MockQuickSightAPI) UpdateKeyRegistrationRequest(arg0 *quicksight.UpdateKeyRegistrationInput) (*request.Request, *quicksight.UpdateKeyRegistrationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKeyRegistrationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateKeyRegistrationOutput)
	return ret0, ret1
}

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

// UpdateKeyRegistrationWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateKeyRegistrationWithContext(arg0 aws.Context, arg1 *quicksight.UpdateKeyRegistrationInput, arg2 ...request.Option) (*quicksight.UpdateKeyRegistrationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateKeyRegistrationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateKeyRegistrationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePublicSharingSettings mocks base method.
func (m *MockQuickSightAPI) UpdatePublicSharingSettings(arg0 *quicksight.UpdatePublicSharingSettingsInput) (*quicksight.UpdatePublicSharingSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePublicSharingSettings", arg0)
	ret0, _ := ret[0].(*quicksight.UpdatePublicSharingSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePublicSharingSettingsRequest mocks base method.
func (m *MockQuickSightAPI) UpdatePublicSharingSettingsRequest(arg0 *quicksight.UpdatePublicSharingSettingsInput) (*request.Request, *quicksight.UpdatePublicSharingSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePublicSharingSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdatePublicSharingSettingsOutput)
	return ret0, ret1
}

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

// UpdatePublicSharingSettingsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdatePublicSharingSettingsWithContext(arg0 aws.Context, arg1 *quicksight.UpdatePublicSharingSettingsInput, arg2 ...request.Option) (*quicksight.UpdatePublicSharingSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePublicSharingSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdatePublicSharingSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) UpdateRefreshSchedule(arg0 *quicksight.UpdateRefreshScheduleInput) (*quicksight.UpdateRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) UpdateRefreshScheduleRequest(arg0 *quicksight.UpdateRefreshScheduleInput) (*request.Request, *quicksight.UpdateRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateRefreshScheduleOutput)
	return ret0, ret1
}

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

// UpdateRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.UpdateRefreshScheduleInput, arg2 ...request.Option) (*quicksight.UpdateRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRoleCustomPermission mocks base method.
func (m *MockQuickSightAPI) UpdateRoleCustomPermission(arg0 *quicksight.UpdateRoleCustomPermissionInput) (*quicksight.UpdateRoleCustomPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRoleCustomPermission", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateRoleCustomPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRoleCustomPermissionRequest mocks base method.
func (m *MockQuickSightAPI) UpdateRoleCustomPermissionRequest(arg0 *quicksight.UpdateRoleCustomPermissionInput) (*request.Request, *quicksight.UpdateRoleCustomPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRoleCustomPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateRoleCustomPermissionOutput)
	return ret0, ret1
}

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

// UpdateRoleCustomPermissionWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateRoleCustomPermissionWithContext(arg0 aws.Context, arg1 *quicksight.UpdateRoleCustomPermissionInput, arg2 ...request.Option) (*quicksight.UpdateRoleCustomPermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRoleCustomPermissionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateRoleCustomPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSPICECapacityConfiguration mocks base method.
func (m *MockQuickSightAPI) UpdateSPICECapacityConfiguration(arg0 *quicksight.UpdateSPICECapacityConfigurationInput) (*quicksight.UpdateSPICECapacityConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSPICECapacityConfiguration", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateSPICECapacityConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSPICECapacityConfigurationRequest mocks base method.
func (m *MockQuickSightAPI) UpdateSPICECapacityConfigurationRequest(arg0 *quicksight.UpdateSPICECapacityConfigurationInput) (*request.Request, *quicksight.UpdateSPICECapacityConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSPICECapacityConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateSPICECapacityConfigurationOutput)
	return ret0, ret1
}

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

// UpdateSPICECapacityConfigurationWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateSPICECapacityConfigurationWithContext(arg0 aws.Context, arg1 *quicksight.UpdateSPICECapacityConfigurationInput, arg2 ...request.Option) (*quicksight.UpdateSPICECapacityConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateSPICECapacityConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateSPICECapacityConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplate mocks base method.
func (m *MockQuickSightAPI) UpdateTemplate(arg0 *quicksight.UpdateTemplateInput) (*quicksight.UpdateTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplate", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplateAlias mocks base method.
func (m *MockQuickSightAPI) UpdateTemplateAlias(arg0 *quicksight.UpdateTemplateAliasInput) (*quicksight.UpdateTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateAlias", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplateAliasRequest mocks base method.
func (m *MockQuickSightAPI) UpdateTemplateAliasRequest(arg0 *quicksight.UpdateTemplateAliasInput) (*request.Request, *quicksight.UpdateTemplateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateTemplateAliasOutput)
	return ret0, ret1
}

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

// UpdateTemplateAliasWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateTemplateAliasWithContext(arg0 aws.Context, arg1 *quicksight.UpdateTemplateAliasInput, arg2 ...request.Option) (*quicksight.UpdateTemplateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTemplateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateTemplateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplatePermissions mocks base method.
func (m *MockQuickSightAPI) UpdateTemplatePermissions(arg0 *quicksight.UpdateTemplatePermissionsInput) (*quicksight.UpdateTemplatePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplatePermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateTemplatePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplatePermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateTemplatePermissionsRequest(arg0 *quicksight.UpdateTemplatePermissionsInput) (*request.Request, *quicksight.UpdateTemplatePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplatePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateTemplatePermissionsOutput)
	return ret0, ret1
}

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

// UpdateTemplatePermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateTemplatePermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateTemplatePermissionsInput, arg2 ...request.Option) (*quicksight.UpdateTemplatePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTemplatePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateTemplatePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplateRequest mocks base method.
func (m *MockQuickSightAPI) UpdateTemplateRequest(arg0 *quicksight.UpdateTemplateInput) (*request.Request, *quicksight.UpdateTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateTemplateOutput)
	return ret0, ret1
}

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

// UpdateTemplateWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateTemplateWithContext(arg0 aws.Context, arg1 *quicksight.UpdateTemplateInput, arg2 ...request.Option) (*quicksight.UpdateTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTheme mocks base method.
func (m *MockQuickSightAPI) UpdateTheme(arg0 *quicksight.UpdateThemeInput) (*quicksight.UpdateThemeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTheme", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateThemeAlias mocks base method.
func (m *MockQuickSightAPI) UpdateThemeAlias(arg0 *quicksight.UpdateThemeAliasInput) (*quicksight.UpdateThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateThemeAlias", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateThemeAliasRequest mocks base method.
func (m *MockQuickSightAPI) UpdateThemeAliasRequest(arg0 *quicksight.UpdateThemeAliasInput) (*request.Request, *quicksight.UpdateThemeAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateThemeAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateThemeAliasOutput)
	return ret0, ret1
}

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

// UpdateThemeAliasWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateThemeAliasWithContext(arg0 aws.Context, arg1 *quicksight.UpdateThemeAliasInput, arg2 ...request.Option) (*quicksight.UpdateThemeAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateThemeAliasWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateThemeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateThemePermissions mocks base method.
func (m *MockQuickSightAPI) UpdateThemePermissions(arg0 *quicksight.UpdateThemePermissionsInput) (*quicksight.UpdateThemePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateThemePermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateThemePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateThemePermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateThemePermissionsRequest(arg0 *quicksight.UpdateThemePermissionsInput) (*request.Request, *quicksight.UpdateThemePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateThemePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateThemePermissionsOutput)
	return ret0, ret1
}

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

// UpdateThemePermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateThemePermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateThemePermissionsInput, arg2 ...request.Option) (*quicksight.UpdateThemePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateThemePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateThemePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateThemeRequest mocks base method.
func (m *MockQuickSightAPI) UpdateThemeRequest(arg0 *quicksight.UpdateThemeInput) (*request.Request, *quicksight.UpdateThemeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateThemeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateThemeOutput)
	return ret0, ret1
}

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

// UpdateThemeWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateThemeWithContext(arg0 aws.Context, arg1 *quicksight.UpdateThemeInput, arg2 ...request.Option) (*quicksight.UpdateThemeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateThemeWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateThemeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTopic mocks base method.
func (m *MockQuickSightAPI) UpdateTopic(arg0 *quicksight.UpdateTopicInput) (*quicksight.UpdateTopicOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTopic", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTopicPermissions mocks base method.
func (m *MockQuickSightAPI) UpdateTopicPermissions(arg0 *quicksight.UpdateTopicPermissionsInput) (*quicksight.UpdateTopicPermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTopicPermissions", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateTopicPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTopicPermissionsRequest mocks base method.
func (m *MockQuickSightAPI) UpdateTopicPermissionsRequest(arg0 *quicksight.UpdateTopicPermissionsInput) (*request.Request, *quicksight.UpdateTopicPermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTopicPermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateTopicPermissionsOutput)
	return ret0, ret1
}

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

// UpdateTopicPermissionsWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateTopicPermissionsWithContext(arg0 aws.Context, arg1 *quicksight.UpdateTopicPermissionsInput, arg2 ...request.Option) (*quicksight.UpdateTopicPermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTopicPermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateTopicPermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTopicRefreshSchedule mocks base method.
func (m *MockQuickSightAPI) UpdateTopicRefreshSchedule(arg0 *quicksight.UpdateTopicRefreshScheduleInput) (*quicksight.UpdateTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTopicRefreshSchedule", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTopicRefreshScheduleRequest mocks base method.
func (m *MockQuickSightAPI) UpdateTopicRefreshScheduleRequest(arg0 *quicksight.UpdateTopicRefreshScheduleInput) (*request.Request, *quicksight.UpdateTopicRefreshScheduleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTopicRefreshScheduleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateTopicRefreshScheduleOutput)
	return ret0, ret1
}

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

// UpdateTopicRefreshScheduleWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateTopicRefreshScheduleWithContext(arg0 aws.Context, arg1 *quicksight.UpdateTopicRefreshScheduleInput, arg2 ...request.Option) (*quicksight.UpdateTopicRefreshScheduleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTopicRefreshScheduleWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateTopicRefreshScheduleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTopicRequest mocks base method.
func (m *MockQuickSightAPI) UpdateTopicRequest(arg0 *quicksight.UpdateTopicInput) (*request.Request, *quicksight.UpdateTopicOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateTopicOutput)
	return ret0, ret1
}

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

// UpdateTopicWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateTopicWithContext(arg0 aws.Context, arg1 *quicksight.UpdateTopicInput, arg2 ...request.Option) (*quicksight.UpdateTopicOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTopicWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUser mocks base method.
func (m *MockQuickSightAPI) UpdateUser(arg0 *quicksight.UpdateUserInput) (*quicksight.UpdateUserOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUser", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUserRequest mocks base method.
func (m *MockQuickSightAPI) UpdateUserRequest(arg0 *quicksight.UpdateUserInput) (*request.Request, *quicksight.UpdateUserOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateUserOutput)
	return ret0, ret1
}

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

// UpdateUserWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateUserWithContext(arg0 aws.Context, arg1 *quicksight.UpdateUserInput, arg2 ...request.Option) (*quicksight.UpdateUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateVPCConnection mocks base method.
func (m *MockQuickSightAPI) UpdateVPCConnection(arg0 *quicksight.UpdateVPCConnectionInput) (*quicksight.UpdateVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVPCConnection", arg0)
	ret0, _ := ret[0].(*quicksight.UpdateVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateVPCConnectionRequest mocks base method.
func (m *MockQuickSightAPI) UpdateVPCConnectionRequest(arg0 *quicksight.UpdateVPCConnectionInput) (*request.Request, *quicksight.UpdateVPCConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVPCConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*quicksight.UpdateVPCConnectionOutput)
	return ret0, ret1
}

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

// UpdateVPCConnectionWithContext mocks base method.
func (m *MockQuickSightAPI) UpdateVPCConnectionWithContext(arg0 aws.Context, arg1 *quicksight.UpdateVPCConnectionInput, arg2 ...request.Option) (*quicksight.UpdateVPCConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateVPCConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*quicksight.UpdateVPCConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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