quicksight.go

// Code generated by MockGen. DO NOT EDIT.
// Source: quicksight.go

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

import (
	context "context"
	reflect "reflect"

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

// MockQuicksightClient is a mock of QuicksightClient interface.
type MockQuicksightClient struct {
	ctrl     *gomock.Controller
	recorder *MockQuicksightClientMockRecorder
}

// MockQuicksightClientMockRecorder is the mock recorder for MockQuicksightClient.
type MockQuicksightClientMockRecorder struct {
	mock *MockQuicksightClient
}

// NewMockQuicksightClient creates a new mock instance.
func NewMockQuicksightClient(ctrl *gomock.Controller) *MockQuicksightClient {
	mock := &MockQuicksightClient{ctrl: ctrl}
	mock.recorder = &MockQuicksightClientMockRecorder{mock}
	return mock
}

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

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

// DescribeAccountCustomization indicates an expected call of DescribeAccountCustomization.
func (mr *MockQuicksightClientMockRecorder) DescribeAccountCustomization(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, "DescribeAccountCustomization", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAccountCustomization), varargs...)
}

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

// DescribeAccountSettings indicates an expected call of DescribeAccountSettings.
func (mr *MockQuicksightClientMockRecorder) DescribeAccountSettings(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, "DescribeAccountSettings", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAccountSettings), varargs...)
}

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

// DescribeAccountSubscription indicates an expected call of DescribeAccountSubscription.
func (mr *MockQuicksightClientMockRecorder) DescribeAccountSubscription(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, "DescribeAccountSubscription", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAccountSubscription), varargs...)
}

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

// DescribeAnalysis indicates an expected call of DescribeAnalysis.
func (mr *MockQuicksightClientMockRecorder) DescribeAnalysis(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, "DescribeAnalysis", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAnalysis), varargs...)
}

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

// DescribeAnalysisDefinition indicates an expected call of DescribeAnalysisDefinition.
func (mr *MockQuicksightClientMockRecorder) DescribeAnalysisDefinition(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, "DescribeAnalysisDefinition", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAnalysisDefinition), varargs...)
}

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

// DescribeAnalysisPermissions indicates an expected call of DescribeAnalysisPermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeAnalysisPermissions(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, "DescribeAnalysisPermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAnalysisPermissions), varargs...)
}

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

// DescribeAssetBundleExportJob indicates an expected call of DescribeAssetBundleExportJob.
func (mr *MockQuicksightClientMockRecorder) DescribeAssetBundleExportJob(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, "DescribeAssetBundleExportJob", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAssetBundleExportJob), varargs...)
}

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

// DescribeAssetBundleImportJob indicates an expected call of DescribeAssetBundleImportJob.
func (mr *MockQuicksightClientMockRecorder) DescribeAssetBundleImportJob(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, "DescribeAssetBundleImportJob", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeAssetBundleImportJob), varargs...)
}

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

// DescribeDashboard indicates an expected call of DescribeDashboard.
func (mr *MockQuicksightClientMockRecorder) DescribeDashboard(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, "DescribeDashboard", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDashboard), varargs...)
}

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

// DescribeDashboardDefinition indicates an expected call of DescribeDashboardDefinition.
func (mr *MockQuicksightClientMockRecorder) DescribeDashboardDefinition(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, "DescribeDashboardDefinition", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDashboardDefinition), varargs...)
}

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

// DescribeDashboardPermissions indicates an expected call of DescribeDashboardPermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeDashboardPermissions(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, "DescribeDashboardPermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDashboardPermissions), varargs...)
}

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

// DescribeDashboardSnapshotJob indicates an expected call of DescribeDashboardSnapshotJob.
func (mr *MockQuicksightClientMockRecorder) DescribeDashboardSnapshotJob(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, "DescribeDashboardSnapshotJob", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDashboardSnapshotJob), varargs...)
}

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

// DescribeDashboardSnapshotJobResult indicates an expected call of DescribeDashboardSnapshotJobResult.
func (mr *MockQuicksightClientMockRecorder) DescribeDashboardSnapshotJobResult(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, "DescribeDashboardSnapshotJobResult", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDashboardSnapshotJobResult), varargs...)
}

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

// DescribeDataSet indicates an expected call of DescribeDataSet.
func (mr *MockQuicksightClientMockRecorder) DescribeDataSet(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, "DescribeDataSet", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDataSet), varargs...)
}

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

// DescribeDataSetPermissions indicates an expected call of DescribeDataSetPermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeDataSetPermissions(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, "DescribeDataSetPermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDataSetPermissions), varargs...)
}

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

// DescribeDataSetRefreshProperties indicates an expected call of DescribeDataSetRefreshProperties.
func (mr *MockQuicksightClientMockRecorder) DescribeDataSetRefreshProperties(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, "DescribeDataSetRefreshProperties", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDataSetRefreshProperties), varargs...)
}

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

// DescribeDataSource indicates an expected call of DescribeDataSource.
func (mr *MockQuicksightClientMockRecorder) DescribeDataSource(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, "DescribeDataSource", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDataSource), varargs...)
}

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

// DescribeDataSourcePermissions indicates an expected call of DescribeDataSourcePermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeDataSourcePermissions(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, "DescribeDataSourcePermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeDataSourcePermissions), varargs...)
}

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

// DescribeFolder indicates an expected call of DescribeFolder.
func (mr *MockQuicksightClientMockRecorder) DescribeFolder(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, "DescribeFolder", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeFolder), varargs...)
}

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

// DescribeFolderPermissions indicates an expected call of DescribeFolderPermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeFolderPermissions(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, "DescribeFolderPermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeFolderPermissions), varargs...)
}

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

// DescribeFolderResolvedPermissions indicates an expected call of DescribeFolderResolvedPermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeFolderResolvedPermissions(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, "DescribeFolderResolvedPermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeFolderResolvedPermissions), varargs...)
}

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

// DescribeGroup indicates an expected call of DescribeGroup.
func (mr *MockQuicksightClientMockRecorder) DescribeGroup(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, "DescribeGroup", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeGroup), varargs...)
}

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

// DescribeGroupMembership indicates an expected call of DescribeGroupMembership.
func (mr *MockQuicksightClientMockRecorder) DescribeGroupMembership(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, "DescribeGroupMembership", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeGroupMembership), varargs...)
}

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

// DescribeIAMPolicyAssignment indicates an expected call of DescribeIAMPolicyAssignment.
func (mr *MockQuicksightClientMockRecorder) DescribeIAMPolicyAssignment(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, "DescribeIAMPolicyAssignment", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeIAMPolicyAssignment), varargs...)
}

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

// DescribeIngestion indicates an expected call of DescribeIngestion.
func (mr *MockQuicksightClientMockRecorder) DescribeIngestion(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, "DescribeIngestion", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeIngestion), varargs...)
}

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

// DescribeIpRestriction indicates an expected call of DescribeIpRestriction.
func (mr *MockQuicksightClientMockRecorder) DescribeIpRestriction(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, "DescribeIpRestriction", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeIpRestriction), varargs...)
}

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

// DescribeNamespace indicates an expected call of DescribeNamespace.
func (mr *MockQuicksightClientMockRecorder) DescribeNamespace(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, "DescribeNamespace", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeNamespace), varargs...)
}

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

// DescribeRefreshSchedule indicates an expected call of DescribeRefreshSchedule.
func (mr *MockQuicksightClientMockRecorder) DescribeRefreshSchedule(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, "DescribeRefreshSchedule", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeRefreshSchedule), varargs...)
}

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

// DescribeRoleCustomPermission indicates an expected call of DescribeRoleCustomPermission.
func (mr *MockQuicksightClientMockRecorder) DescribeRoleCustomPermission(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, "DescribeRoleCustomPermission", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeRoleCustomPermission), varargs...)
}

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

// DescribeTemplate indicates an expected call of DescribeTemplate.
func (mr *MockQuicksightClientMockRecorder) DescribeTemplate(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, "DescribeTemplate", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTemplate), varargs...)
}

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

// DescribeTemplateAlias indicates an expected call of DescribeTemplateAlias.
func (mr *MockQuicksightClientMockRecorder) DescribeTemplateAlias(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, "DescribeTemplateAlias", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTemplateAlias), varargs...)
}

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

// DescribeTemplateDefinition indicates an expected call of DescribeTemplateDefinition.
func (mr *MockQuicksightClientMockRecorder) DescribeTemplateDefinition(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, "DescribeTemplateDefinition", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTemplateDefinition), varargs...)
}

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

// DescribeTemplatePermissions indicates an expected call of DescribeTemplatePermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeTemplatePermissions(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, "DescribeTemplatePermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTemplatePermissions), varargs...)
}

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

// DescribeTheme indicates an expected call of DescribeTheme.
func (mr *MockQuicksightClientMockRecorder) DescribeTheme(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, "DescribeTheme", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTheme), varargs...)
}

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

// DescribeThemeAlias indicates an expected call of DescribeThemeAlias.
func (mr *MockQuicksightClientMockRecorder) DescribeThemeAlias(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, "DescribeThemeAlias", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeThemeAlias), varargs...)
}

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

// DescribeThemePermissions indicates an expected call of DescribeThemePermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeThemePermissions(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, "DescribeThemePermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeThemePermissions), varargs...)
}

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

// DescribeTopic indicates an expected call of DescribeTopic.
func (mr *MockQuicksightClientMockRecorder) DescribeTopic(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, "DescribeTopic", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTopic), varargs...)
}

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

// DescribeTopicPermissions indicates an expected call of DescribeTopicPermissions.
func (mr *MockQuicksightClientMockRecorder) DescribeTopicPermissions(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, "DescribeTopicPermissions", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTopicPermissions), varargs...)
}

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

// DescribeTopicRefresh indicates an expected call of DescribeTopicRefresh.
func (mr *MockQuicksightClientMockRecorder) DescribeTopicRefresh(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, "DescribeTopicRefresh", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTopicRefresh), varargs...)
}

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

// DescribeTopicRefreshSchedule indicates an expected call of DescribeTopicRefreshSchedule.
func (mr *MockQuicksightClientMockRecorder) DescribeTopicRefreshSchedule(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, "DescribeTopicRefreshSchedule", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeTopicRefreshSchedule), varargs...)
}

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

// DescribeUser indicates an expected call of DescribeUser.
func (mr *MockQuicksightClientMockRecorder) DescribeUser(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, "DescribeUser", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeUser), varargs...)
}

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

// DescribeVPCConnection indicates an expected call of DescribeVPCConnection.
func (mr *MockQuicksightClientMockRecorder) DescribeVPCConnection(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, "DescribeVPCConnection", reflect.TypeOf((*MockQuicksightClient)(nil).DescribeVPCConnection), varargs...)
}

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

// GetDashboardEmbedUrl indicates an expected call of GetDashboardEmbedUrl.
func (mr *MockQuicksightClientMockRecorder) GetDashboardEmbedUrl(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, "GetDashboardEmbedUrl", reflect.TypeOf((*MockQuicksightClient)(nil).GetDashboardEmbedUrl), varargs...)
}

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

// GetSessionEmbedUrl indicates an expected call of GetSessionEmbedUrl.
func (mr *MockQuicksightClientMockRecorder) GetSessionEmbedUrl(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, "GetSessionEmbedUrl", reflect.TypeOf((*MockQuicksightClient)(nil).GetSessionEmbedUrl), varargs...)
}

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

// ListAnalyses indicates an expected call of ListAnalyses.
func (mr *MockQuicksightClientMockRecorder) ListAnalyses(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, "ListAnalyses", reflect.TypeOf((*MockQuicksightClient)(nil).ListAnalyses), varargs...)
}

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

// ListAssetBundleExportJobs indicates an expected call of ListAssetBundleExportJobs.
func (mr *MockQuicksightClientMockRecorder) ListAssetBundleExportJobs(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, "ListAssetBundleExportJobs", reflect.TypeOf((*MockQuicksightClient)(nil).ListAssetBundleExportJobs), varargs...)
}

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

// ListAssetBundleImportJobs indicates an expected call of ListAssetBundleImportJobs.
func (mr *MockQuicksightClientMockRecorder) ListAssetBundleImportJobs(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, "ListAssetBundleImportJobs", reflect.TypeOf((*MockQuicksightClient)(nil).ListAssetBundleImportJobs), varargs...)
}

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

// ListDashboardVersions indicates an expected call of ListDashboardVersions.
func (mr *MockQuicksightClientMockRecorder) ListDashboardVersions(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, "ListDashboardVersions", reflect.TypeOf((*MockQuicksightClient)(nil).ListDashboardVersions), varargs...)
}

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

// ListDashboards indicates an expected call of ListDashboards.
func (mr *MockQuicksightClientMockRecorder) ListDashboards(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, "ListDashboards", reflect.TypeOf((*MockQuicksightClient)(nil).ListDashboards), varargs...)
}

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

// ListDataSets indicates an expected call of ListDataSets.
func (mr *MockQuicksightClientMockRecorder) ListDataSets(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, "ListDataSets", reflect.TypeOf((*MockQuicksightClient)(nil).ListDataSets), varargs...)
}

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

// ListDataSources indicates an expected call of ListDataSources.
func (mr *MockQuicksightClientMockRecorder) ListDataSources(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, "ListDataSources", reflect.TypeOf((*MockQuicksightClient)(nil).ListDataSources), varargs...)
}

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

// ListFolderMembers indicates an expected call of ListFolderMembers.
func (mr *MockQuicksightClientMockRecorder) ListFolderMembers(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, "ListFolderMembers", reflect.TypeOf((*MockQuicksightClient)(nil).ListFolderMembers), varargs...)
}

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

// ListFolders indicates an expected call of ListFolders.
func (mr *MockQuicksightClientMockRecorder) ListFolders(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, "ListFolders", reflect.TypeOf((*MockQuicksightClient)(nil).ListFolders), varargs...)
}

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

// ListGroupMemberships indicates an expected call of ListGroupMemberships.
func (mr *MockQuicksightClientMockRecorder) ListGroupMemberships(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, "ListGroupMemberships", reflect.TypeOf((*MockQuicksightClient)(nil).ListGroupMemberships), varargs...)
}

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

// ListGroups indicates an expected call of ListGroups.
func (mr *MockQuicksightClientMockRecorder) ListGroups(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, "ListGroups", reflect.TypeOf((*MockQuicksightClient)(nil).ListGroups), varargs...)
}

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

// ListIAMPolicyAssignments indicates an expected call of ListIAMPolicyAssignments.
func (mr *MockQuicksightClientMockRecorder) ListIAMPolicyAssignments(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, "ListIAMPolicyAssignments", reflect.TypeOf((*MockQuicksightClient)(nil).ListIAMPolicyAssignments), varargs...)
}

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

// ListIAMPolicyAssignmentsForUser indicates an expected call of ListIAMPolicyAssignmentsForUser.
func (mr *MockQuicksightClientMockRecorder) ListIAMPolicyAssignmentsForUser(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, "ListIAMPolicyAssignmentsForUser", reflect.TypeOf((*MockQuicksightClient)(nil).ListIAMPolicyAssignmentsForUser), varargs...)
}

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

// ListIdentityPropagationConfigs indicates an expected call of ListIdentityPropagationConfigs.
func (mr *MockQuicksightClientMockRecorder) ListIdentityPropagationConfigs(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, "ListIdentityPropagationConfigs", reflect.TypeOf((*MockQuicksightClient)(nil).ListIdentityPropagationConfigs), varargs...)
}

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

// ListIngestions indicates an expected call of ListIngestions.
func (mr *MockQuicksightClientMockRecorder) ListIngestions(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, "ListIngestions", reflect.TypeOf((*MockQuicksightClient)(nil).ListIngestions), varargs...)
}

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

// ListNamespaces indicates an expected call of ListNamespaces.
func (mr *MockQuicksightClientMockRecorder) ListNamespaces(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, "ListNamespaces", reflect.TypeOf((*MockQuicksightClient)(nil).ListNamespaces), varargs...)
}

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

// ListRefreshSchedules indicates an expected call of ListRefreshSchedules.
func (mr *MockQuicksightClientMockRecorder) ListRefreshSchedules(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, "ListRefreshSchedules", reflect.TypeOf((*MockQuicksightClient)(nil).ListRefreshSchedules), varargs...)
}

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

// ListRoleMemberships indicates an expected call of ListRoleMemberships.
func (mr *MockQuicksightClientMockRecorder) ListRoleMemberships(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, "ListRoleMemberships", reflect.TypeOf((*MockQuicksightClient)(nil).ListRoleMemberships), varargs...)
}

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

// ListTagsForResource indicates an expected call of ListTagsForResource.
func (mr *MockQuicksightClientMockRecorder) ListTagsForResource(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, "ListTagsForResource", reflect.TypeOf((*MockQuicksightClient)(nil).ListTagsForResource), varargs...)
}

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

// ListTemplateAliases indicates an expected call of ListTemplateAliases.
func (mr *MockQuicksightClientMockRecorder) ListTemplateAliases(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, "ListTemplateAliases", reflect.TypeOf((*MockQuicksightClient)(nil).ListTemplateAliases), varargs...)
}

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

// ListTemplateVersions indicates an expected call of ListTemplateVersions.
func (mr *MockQuicksightClientMockRecorder) ListTemplateVersions(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, "ListTemplateVersions", reflect.TypeOf((*MockQuicksightClient)(nil).ListTemplateVersions), varargs...)
}

// ListTemplates mocks base method.
func (m *MockQuicksightClient) ListTemplates(arg0 context.Context, arg1 *quicksight.ListTemplatesInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListTemplatesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTemplates", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTemplatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTemplates indicates an expected call of ListTemplates.
func (mr *MockQuicksightClientMockRecorder) ListTemplates(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, "ListTemplates", reflect.TypeOf((*MockQuicksightClient)(nil).ListTemplates), varargs...)
}

// ListThemeAliases mocks base method.
func (m *MockQuicksightClient) ListThemeAliases(arg0 context.Context, arg1 *quicksight.ListThemeAliasesInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListThemeAliasesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemeAliases", varargs...)
	ret0, _ := ret[0].(*quicksight.ListThemeAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListThemeAliases indicates an expected call of ListThemeAliases.
func (mr *MockQuicksightClientMockRecorder) ListThemeAliases(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, "ListThemeAliases", reflect.TypeOf((*MockQuicksightClient)(nil).ListThemeAliases), varargs...)
}

// ListThemeVersions mocks base method.
func (m *MockQuicksightClient) ListThemeVersions(arg0 context.Context, arg1 *quicksight.ListThemeVersionsInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListThemeVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemeVersions", varargs...)
	ret0, _ := ret[0].(*quicksight.ListThemeVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListThemeVersions indicates an expected call of ListThemeVersions.
func (mr *MockQuicksightClientMockRecorder) ListThemeVersions(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, "ListThemeVersions", reflect.TypeOf((*MockQuicksightClient)(nil).ListThemeVersions), varargs...)
}

// ListThemes mocks base method.
func (m *MockQuicksightClient) ListThemes(arg0 context.Context, arg1 *quicksight.ListThemesInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListThemesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListThemes", varargs...)
	ret0, _ := ret[0].(*quicksight.ListThemesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListThemes indicates an expected call of ListThemes.
func (mr *MockQuicksightClientMockRecorder) ListThemes(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, "ListThemes", reflect.TypeOf((*MockQuicksightClient)(nil).ListThemes), varargs...)
}

// ListTopicRefreshSchedules mocks base method.
func (m *MockQuicksightClient) ListTopicRefreshSchedules(arg0 context.Context, arg1 *quicksight.ListTopicRefreshSchedulesInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListTopicRefreshSchedulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicRefreshSchedules", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTopicRefreshSchedulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopicRefreshSchedules indicates an expected call of ListTopicRefreshSchedules.
func (mr *MockQuicksightClientMockRecorder) ListTopicRefreshSchedules(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, "ListTopicRefreshSchedules", reflect.TypeOf((*MockQuicksightClient)(nil).ListTopicRefreshSchedules), varargs...)
}

// ListTopics mocks base method.
func (m *MockQuicksightClient) ListTopics(arg0 context.Context, arg1 *quicksight.ListTopicsInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListTopicsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopics", varargs...)
	ret0, _ := ret[0].(*quicksight.ListTopicsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopics indicates an expected call of ListTopics.
func (mr *MockQuicksightClientMockRecorder) ListTopics(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, "ListTopics", reflect.TypeOf((*MockQuicksightClient)(nil).ListTopics), varargs...)
}

// ListUserGroups mocks base method.
func (m *MockQuicksightClient) ListUserGroups(arg0 context.Context, arg1 *quicksight.ListUserGroupsInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListUserGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserGroups", varargs...)
	ret0, _ := ret[0].(*quicksight.ListUserGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserGroups indicates an expected call of ListUserGroups.
func (mr *MockQuicksightClientMockRecorder) ListUserGroups(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, "ListUserGroups", reflect.TypeOf((*MockQuicksightClient)(nil).ListUserGroups), varargs...)
}

// ListUsers mocks base method.
func (m *MockQuicksightClient) ListUsers(arg0 context.Context, arg1 *quicksight.ListUsersInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListUsersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUsers", varargs...)
	ret0, _ := ret[0].(*quicksight.ListUsersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUsers indicates an expected call of ListUsers.
func (mr *MockQuicksightClientMockRecorder) ListUsers(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, "ListUsers", reflect.TypeOf((*MockQuicksightClient)(nil).ListUsers), varargs...)
}

// ListVPCConnections mocks base method.
func (m *MockQuicksightClient) ListVPCConnections(arg0 context.Context, arg1 *quicksight.ListVPCConnectionsInput, arg2 ...func(*quicksight.Options)) (*quicksight.ListVPCConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVPCConnections", varargs...)
	ret0, _ := ret[0].(*quicksight.ListVPCConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVPCConnections indicates an expected call of ListVPCConnections.
func (mr *MockQuicksightClientMockRecorder) ListVPCConnections(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, "ListVPCConnections", reflect.TypeOf((*MockQuicksightClient)(nil).ListVPCConnections), varargs...)
}

// SearchAnalyses mocks base method.
func (m *MockQuicksightClient) SearchAnalyses(arg0 context.Context, arg1 *quicksight.SearchAnalysesInput, arg2 ...func(*quicksight.Options)) (*quicksight.SearchAnalysesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchAnalyses", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchAnalyses indicates an expected call of SearchAnalyses.
func (mr *MockQuicksightClientMockRecorder) SearchAnalyses(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, "SearchAnalyses", reflect.TypeOf((*MockQuicksightClient)(nil).SearchAnalyses), varargs...)
}

// SearchDashboards mocks base method.
func (m *MockQuicksightClient) SearchDashboards(arg0 context.Context, arg1 *quicksight.SearchDashboardsInput, arg2 ...func(*quicksight.Options)) (*quicksight.SearchDashboardsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDashboards", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchDashboardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchDashboards indicates an expected call of SearchDashboards.
func (mr *MockQuicksightClientMockRecorder) SearchDashboards(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, "SearchDashboards", reflect.TypeOf((*MockQuicksightClient)(nil).SearchDashboards), varargs...)
}

// SearchDataSets mocks base method.
func (m *MockQuicksightClient) SearchDataSets(arg0 context.Context, arg1 *quicksight.SearchDataSetsInput, arg2 ...func(*quicksight.Options)) (*quicksight.SearchDataSetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDataSets", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchDataSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchDataSets indicates an expected call of SearchDataSets.
func (mr *MockQuicksightClientMockRecorder) SearchDataSets(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, "SearchDataSets", reflect.TypeOf((*MockQuicksightClient)(nil).SearchDataSets), varargs...)
}

// SearchDataSources mocks base method.
func (m *MockQuicksightClient) SearchDataSources(arg0 context.Context, arg1 *quicksight.SearchDataSourcesInput, arg2 ...func(*quicksight.Options)) (*quicksight.SearchDataSourcesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchDataSources", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchDataSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchDataSources indicates an expected call of SearchDataSources.
func (mr *MockQuicksightClientMockRecorder) SearchDataSources(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, "SearchDataSources", reflect.TypeOf((*MockQuicksightClient)(nil).SearchDataSources), varargs...)
}

// SearchFolders mocks base method.
func (m *MockQuicksightClient) SearchFolders(arg0 context.Context, arg1 *quicksight.SearchFoldersInput, arg2 ...func(*quicksight.Options)) (*quicksight.SearchFoldersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchFolders", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchFoldersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchFolders indicates an expected call of SearchFolders.
func (mr *MockQuicksightClientMockRecorder) SearchFolders(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, "SearchFolders", reflect.TypeOf((*MockQuicksightClient)(nil).SearchFolders), varargs...)
}

// SearchGroups mocks base method.
func (m *MockQuicksightClient) SearchGroups(arg0 context.Context, arg1 *quicksight.SearchGroupsInput, arg2 ...func(*quicksight.Options)) (*quicksight.SearchGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchGroups", varargs...)
	ret0, _ := ret[0].(*quicksight.SearchGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchGroups indicates an expected call of SearchGroups.
func (mr *MockQuicksightClientMockRecorder) SearchGroups(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, "SearchGroups", reflect.TypeOf((*MockQuicksightClient)(nil).SearchGroups), varargs...)
}