performance_advisor_api.go

// Code generated by mockery. DO NOT EDIT.

package mockadmin

import (
	context "context"

	admin "go.mongodb.org/atlas-sdk/v20231115008/admin"

	http "net/http"

	mock "github.com/stretchr/testify/mock"
)

// PerformanceAdvisorApi is an autogenerated mock type for the PerformanceAdvisorApi type
type PerformanceAdvisorApi struct {
	mock.Mock
}

type PerformanceAdvisorApi_Expecter struct {
	mock *mock.Mock
}

func (_m *PerformanceAdvisorApi) EXPECT() *PerformanceAdvisorApi_Expecter {
	return &PerformanceAdvisorApi_Expecter{mock: &_m.Mock}
}

// DisableSlowOperationThresholding provides a mock function with given fields: ctx, groupId
func (_m *PerformanceAdvisorApi) DisableSlowOperationThresholding(ctx context.Context, groupId string) admin.DisableSlowOperationThresholdingApiRequest {
	ret := _m.Called(ctx, groupId)

	if len(ret) == 0 {
		panic("no return value specified for DisableSlowOperationThresholding")
	}

	var r0 admin.DisableSlowOperationThresholdingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.DisableSlowOperationThresholdingApiRequest); ok {
		r0 = rf(ctx, groupId)
	} else {
		r0 = ret.Get(0).(admin.DisableSlowOperationThresholdingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_DisableSlowOperationThresholding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSlowOperationThresholding'
type PerformanceAdvisorApi_DisableSlowOperationThresholding_Call struct {
	*mock.Call
}

// DisableSlowOperationThresholding is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
func (_e *PerformanceAdvisorApi_Expecter) DisableSlowOperationThresholding(ctx interface{}, groupId interface{}) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call {
	return &PerformanceAdvisorApi_DisableSlowOperationThresholding_Call{Call: _e.mock.On("DisableSlowOperationThresholding", ctx, groupId)}
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call) Run(run func(ctx context.Context, groupId string)) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call) Return(_a0 admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call) RunAndReturn(run func(context.Context, string) admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call {
	_c.Call.Return(run)
	return _c
}

// DisableSlowOperationThresholdingExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) DisableSlowOperationThresholdingExecute(r admin.DisableSlowOperationThresholdingApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for DisableSlowOperationThresholdingExecute")
	}

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(admin.DisableSlowOperationThresholdingApiRequest) (*http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DisableSlowOperationThresholdingApiRequest) *http.Response); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DisableSlowOperationThresholdingApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSlowOperationThresholdingExecute'
type PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call struct {
	*mock.Call
}

// DisableSlowOperationThresholdingExecute is a helper method to define mock.On call
//   - r admin.DisableSlowOperationThresholdingApiRequest
func (_e *PerformanceAdvisorApi_Expecter) DisableSlowOperationThresholdingExecute(r interface{}) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call {
	return &PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call{Call: _e.mock.On("DisableSlowOperationThresholdingExecute", r)}
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call) Run(run func(r admin.DisableSlowOperationThresholdingApiRequest)) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DisableSlowOperationThresholdingApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call) Return(_a0 *http.Response, _a1 error) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call) RunAndReturn(run func(admin.DisableSlowOperationThresholdingApiRequest) (*http.Response, error)) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DisableSlowOperationThresholdingWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) DisableSlowOperationThresholdingWithParams(ctx context.Context, args *admin.DisableSlowOperationThresholdingApiParams) admin.DisableSlowOperationThresholdingApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for DisableSlowOperationThresholdingWithParams")
	}

	var r0 admin.DisableSlowOperationThresholdingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DisableSlowOperationThresholdingApiParams) admin.DisableSlowOperationThresholdingApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DisableSlowOperationThresholdingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSlowOperationThresholdingWithParams'
type PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call struct {
	*mock.Call
}

// DisableSlowOperationThresholdingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DisableSlowOperationThresholdingApiParams
func (_e *PerformanceAdvisorApi_Expecter) DisableSlowOperationThresholdingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call {
	return &PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call{Call: _e.mock.On("DisableSlowOperationThresholdingWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call) Run(run func(ctx context.Context, args *admin.DisableSlowOperationThresholdingApiParams)) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DisableSlowOperationThresholdingApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call) Return(_a0 admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call) RunAndReturn(run func(context.Context, *admin.DisableSlowOperationThresholdingApiParams) admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// EnableSlowOperationThresholding provides a mock function with given fields: ctx, groupId
func (_m *PerformanceAdvisorApi) EnableSlowOperationThresholding(ctx context.Context, groupId string) admin.EnableSlowOperationThresholdingApiRequest {
	ret := _m.Called(ctx, groupId)

	if len(ret) == 0 {
		panic("no return value specified for EnableSlowOperationThresholding")
	}

	var r0 admin.EnableSlowOperationThresholdingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.EnableSlowOperationThresholdingApiRequest); ok {
		r0 = rf(ctx, groupId)
	} else {
		r0 = ret.Get(0).(admin.EnableSlowOperationThresholdingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_EnableSlowOperationThresholding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSlowOperationThresholding'
type PerformanceAdvisorApi_EnableSlowOperationThresholding_Call struct {
	*mock.Call
}

// EnableSlowOperationThresholding is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
func (_e *PerformanceAdvisorApi_Expecter) EnableSlowOperationThresholding(ctx interface{}, groupId interface{}) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call {
	return &PerformanceAdvisorApi_EnableSlowOperationThresholding_Call{Call: _e.mock.On("EnableSlowOperationThresholding", ctx, groupId)}
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call) Run(run func(ctx context.Context, groupId string)) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call) Return(_a0 admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call) RunAndReturn(run func(context.Context, string) admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call {
	_c.Call.Return(run)
	return _c
}

// EnableSlowOperationThresholdingExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) EnableSlowOperationThresholdingExecute(r admin.EnableSlowOperationThresholdingApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for EnableSlowOperationThresholdingExecute")
	}

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(admin.EnableSlowOperationThresholdingApiRequest) (*http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.EnableSlowOperationThresholdingApiRequest) *http.Response); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.EnableSlowOperationThresholdingApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSlowOperationThresholdingExecute'
type PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call struct {
	*mock.Call
}

// EnableSlowOperationThresholdingExecute is a helper method to define mock.On call
//   - r admin.EnableSlowOperationThresholdingApiRequest
func (_e *PerformanceAdvisorApi_Expecter) EnableSlowOperationThresholdingExecute(r interface{}) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call {
	return &PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call{Call: _e.mock.On("EnableSlowOperationThresholdingExecute", r)}
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call) Run(run func(r admin.EnableSlowOperationThresholdingApiRequest)) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.EnableSlowOperationThresholdingApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call) Return(_a0 *http.Response, _a1 error) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call) RunAndReturn(run func(admin.EnableSlowOperationThresholdingApiRequest) (*http.Response, error)) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// EnableSlowOperationThresholdingWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) EnableSlowOperationThresholdingWithParams(ctx context.Context, args *admin.EnableSlowOperationThresholdingApiParams) admin.EnableSlowOperationThresholdingApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for EnableSlowOperationThresholdingWithParams")
	}

	var r0 admin.EnableSlowOperationThresholdingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.EnableSlowOperationThresholdingApiParams) admin.EnableSlowOperationThresholdingApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.EnableSlowOperationThresholdingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSlowOperationThresholdingWithParams'
type PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call struct {
	*mock.Call
}

// EnableSlowOperationThresholdingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.EnableSlowOperationThresholdingApiParams
func (_e *PerformanceAdvisorApi_Expecter) EnableSlowOperationThresholdingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call {
	return &PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call{Call: _e.mock.On("EnableSlowOperationThresholdingWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call) Run(run func(ctx context.Context, args *admin.EnableSlowOperationThresholdingApiParams)) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.EnableSlowOperationThresholdingApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call) Return(_a0 admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call) RunAndReturn(run func(context.Context, *admin.EnableSlowOperationThresholdingApiParams) admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessAutoIndexing provides a mock function with given fields: ctx, groupId, clusterName
func (_m *PerformanceAdvisorApi) GetServerlessAutoIndexing(ctx context.Context, groupId string, clusterName string) admin.GetServerlessAutoIndexingApiRequest {
	ret := _m.Called(ctx, groupId, clusterName)

	if len(ret) == 0 {
		panic("no return value specified for GetServerlessAutoIndexing")
	}

	var r0 admin.GetServerlessAutoIndexingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetServerlessAutoIndexingApiRequest); ok {
		r0 = rf(ctx, groupId, clusterName)
	} else {
		r0 = ret.Get(0).(admin.GetServerlessAutoIndexingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_GetServerlessAutoIndexing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessAutoIndexing'
type PerformanceAdvisorApi_GetServerlessAutoIndexing_Call struct {
	*mock.Call
}

// GetServerlessAutoIndexing is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
func (_e *PerformanceAdvisorApi_Expecter) GetServerlessAutoIndexing(ctx interface{}, groupId interface{}, clusterName interface{}) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call {
	return &PerformanceAdvisorApi_GetServerlessAutoIndexing_Call{Call: _e.mock.On("GetServerlessAutoIndexing", ctx, groupId, clusterName)}
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call) Return(_a0 admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call) RunAndReturn(run func(context.Context, string, string) admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessAutoIndexingExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) GetServerlessAutoIndexingExecute(r admin.GetServerlessAutoIndexingApiRequest) (bool, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for GetServerlessAutoIndexingExecute")
	}

	var r0 bool
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetServerlessAutoIndexingApiRequest) (bool, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetServerlessAutoIndexingApiRequest) bool); ok {
		r0 = rf(r)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(admin.GetServerlessAutoIndexingApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetServerlessAutoIndexingApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessAutoIndexingExecute'
type PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call struct {
	*mock.Call
}

// GetServerlessAutoIndexingExecute is a helper method to define mock.On call
//   - r admin.GetServerlessAutoIndexingApiRequest
func (_e *PerformanceAdvisorApi_Expecter) GetServerlessAutoIndexingExecute(r interface{}) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call {
	return &PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call{Call: _e.mock.On("GetServerlessAutoIndexingExecute", r)}
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call) Run(run func(r admin.GetServerlessAutoIndexingApiRequest)) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetServerlessAutoIndexingApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call) Return(_a0 bool, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call) RunAndReturn(run func(admin.GetServerlessAutoIndexingApiRequest) (bool, *http.Response, error)) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessAutoIndexingWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) GetServerlessAutoIndexingWithParams(ctx context.Context, args *admin.GetServerlessAutoIndexingApiParams) admin.GetServerlessAutoIndexingApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for GetServerlessAutoIndexingWithParams")
	}

	var r0 admin.GetServerlessAutoIndexingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetServerlessAutoIndexingApiParams) admin.GetServerlessAutoIndexingApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetServerlessAutoIndexingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessAutoIndexingWithParams'
type PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call struct {
	*mock.Call
}

// GetServerlessAutoIndexingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetServerlessAutoIndexingApiParams
func (_e *PerformanceAdvisorApi_Expecter) GetServerlessAutoIndexingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call {
	return &PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call{Call: _e.mock.On("GetServerlessAutoIndexingWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call) Run(run func(ctx context.Context, args *admin.GetServerlessAutoIndexingApiParams)) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetServerlessAutoIndexingApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call) Return(_a0 admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessAutoIndexingApiParams) admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListSlowQueries provides a mock function with given fields: ctx, groupId, processId
func (_m *PerformanceAdvisorApi) ListSlowQueries(ctx context.Context, groupId string, processId string) admin.ListSlowQueriesApiRequest {
	ret := _m.Called(ctx, groupId, processId)

	if len(ret) == 0 {
		panic("no return value specified for ListSlowQueries")
	}

	var r0 admin.ListSlowQueriesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSlowQueriesApiRequest); ok {
		r0 = rf(ctx, groupId, processId)
	} else {
		r0 = ret.Get(0).(admin.ListSlowQueriesApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_ListSlowQueries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueries'
type PerformanceAdvisorApi_ListSlowQueries_Call struct {
	*mock.Call
}

// ListSlowQueries is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - processId string
func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueries(ctx interface{}, groupId interface{}, processId interface{}) *PerformanceAdvisorApi_ListSlowQueries_Call {
	return &PerformanceAdvisorApi_ListSlowQueries_Call{Call: _e.mock.On("ListSlowQueries", ctx, groupId, processId)}
}

func (_c *PerformanceAdvisorApi_ListSlowQueries_Call) Run(run func(ctx context.Context, groupId string, processId string)) *PerformanceAdvisorApi_ListSlowQueries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueries_Call) Return(_a0 admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueries_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueries_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueries_Call {
	_c.Call.Return(run)
	return _c
}

// ListSlowQueriesExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) ListSlowQueriesExecute(r admin.ListSlowQueriesApiRequest) (*admin.PerformanceAdvisorSlowQueryList, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListSlowQueriesExecute")
	}

	var r0 *admin.PerformanceAdvisorSlowQueryList
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListSlowQueriesApiRequest) (*admin.PerformanceAdvisorSlowQueryList, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListSlowQueriesApiRequest) *admin.PerformanceAdvisorSlowQueryList); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PerformanceAdvisorSlowQueryList)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListSlowQueriesApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListSlowQueriesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// PerformanceAdvisorApi_ListSlowQueriesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueriesExecute'
type PerformanceAdvisorApi_ListSlowQueriesExecute_Call struct {
	*mock.Call
}

// ListSlowQueriesExecute is a helper method to define mock.On call
//   - r admin.ListSlowQueriesApiRequest
func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueriesExecute(r interface{}) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call {
	return &PerformanceAdvisorApi_ListSlowQueriesExecute_Call{Call: _e.mock.On("ListSlowQueriesExecute", r)}
}

func (_c *PerformanceAdvisorApi_ListSlowQueriesExecute_Call) Run(run func(r admin.ListSlowQueriesApiRequest)) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListSlowQueriesApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueriesExecute_Call) Return(_a0 *admin.PerformanceAdvisorSlowQueryList, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueriesExecute_Call) RunAndReturn(run func(admin.ListSlowQueriesApiRequest) (*admin.PerformanceAdvisorSlowQueryList, *http.Response, error)) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListSlowQueriesWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) ListSlowQueriesWithParams(ctx context.Context, args *admin.ListSlowQueriesApiParams) admin.ListSlowQueriesApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListSlowQueriesWithParams")
	}

	var r0 admin.ListSlowQueriesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSlowQueriesApiParams) admin.ListSlowQueriesApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListSlowQueriesApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_ListSlowQueriesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueriesWithParams'
type PerformanceAdvisorApi_ListSlowQueriesWithParams_Call struct {
	*mock.Call
}

// ListSlowQueriesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListSlowQueriesApiParams
func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueriesWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call {
	return &PerformanceAdvisorApi_ListSlowQueriesWithParams_Call{Call: _e.mock.On("ListSlowQueriesWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSlowQueriesApiParams)) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListSlowQueriesApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call) Return(_a0 admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSlowQueriesApiParams) admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListSlowQueryNamespaces provides a mock function with given fields: ctx, groupId, processId
func (_m *PerformanceAdvisorApi) ListSlowQueryNamespaces(ctx context.Context, groupId string, processId string) admin.ListSlowQueryNamespacesApiRequest {
	ret := _m.Called(ctx, groupId, processId)

	if len(ret) == 0 {
		panic("no return value specified for ListSlowQueryNamespaces")
	}

	var r0 admin.ListSlowQueryNamespacesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSlowQueryNamespacesApiRequest); ok {
		r0 = rf(ctx, groupId, processId)
	} else {
		r0 = ret.Get(0).(admin.ListSlowQueryNamespacesApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_ListSlowQueryNamespaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueryNamespaces'
type PerformanceAdvisorApi_ListSlowQueryNamespaces_Call struct {
	*mock.Call
}

// ListSlowQueryNamespaces is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - processId string
func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueryNamespaces(ctx interface{}, groupId interface{}, processId interface{}) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call {
	return &PerformanceAdvisorApi_ListSlowQueryNamespaces_Call{Call: _e.mock.On("ListSlowQueryNamespaces", ctx, groupId, processId)}
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call) Run(run func(ctx context.Context, groupId string, processId string)) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call) Return(_a0 admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call {
	_c.Call.Return(run)
	return _c
}

// ListSlowQueryNamespacesExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) ListSlowQueryNamespacesExecute(r admin.ListSlowQueryNamespacesApiRequest) (*admin.Namespaces, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListSlowQueryNamespacesExecute")
	}

	var r0 *admin.Namespaces
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListSlowQueryNamespacesApiRequest) (*admin.Namespaces, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListSlowQueryNamespacesApiRequest) *admin.Namespaces); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.Namespaces)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListSlowQueryNamespacesApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListSlowQueryNamespacesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueryNamespacesExecute'
type PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call struct {
	*mock.Call
}

// ListSlowQueryNamespacesExecute is a helper method to define mock.On call
//   - r admin.ListSlowQueryNamespacesApiRequest
func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueryNamespacesExecute(r interface{}) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call {
	return &PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call{Call: _e.mock.On("ListSlowQueryNamespacesExecute", r)}
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call) Run(run func(r admin.ListSlowQueryNamespacesApiRequest)) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListSlowQueryNamespacesApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call) Return(_a0 *admin.Namespaces, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call) RunAndReturn(run func(admin.ListSlowQueryNamespacesApiRequest) (*admin.Namespaces, *http.Response, error)) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListSlowQueryNamespacesWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) ListSlowQueryNamespacesWithParams(ctx context.Context, args *admin.ListSlowQueryNamespacesApiParams) admin.ListSlowQueryNamespacesApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListSlowQueryNamespacesWithParams")
	}

	var r0 admin.ListSlowQueryNamespacesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSlowQueryNamespacesApiParams) admin.ListSlowQueryNamespacesApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListSlowQueryNamespacesApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueryNamespacesWithParams'
type PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call struct {
	*mock.Call
}

// ListSlowQueryNamespacesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListSlowQueryNamespacesApiParams
func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueryNamespacesWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call {
	return &PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call{Call: _e.mock.On("ListSlowQueryNamespacesWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSlowQueryNamespacesApiParams)) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListSlowQueryNamespacesApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call) Return(_a0 admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSlowQueryNamespacesApiParams) admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListSuggestedIndexes provides a mock function with given fields: ctx, groupId, processId
func (_m *PerformanceAdvisorApi) ListSuggestedIndexes(ctx context.Context, groupId string, processId string) admin.ListSuggestedIndexesApiRequest {
	ret := _m.Called(ctx, groupId, processId)

	if len(ret) == 0 {
		panic("no return value specified for ListSuggestedIndexes")
	}

	var r0 admin.ListSuggestedIndexesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSuggestedIndexesApiRequest); ok {
		r0 = rf(ctx, groupId, processId)
	} else {
		r0 = ret.Get(0).(admin.ListSuggestedIndexesApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_ListSuggestedIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSuggestedIndexes'
type PerformanceAdvisorApi_ListSuggestedIndexes_Call struct {
	*mock.Call
}

// ListSuggestedIndexes is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - processId string
func (_e *PerformanceAdvisorApi_Expecter) ListSuggestedIndexes(ctx interface{}, groupId interface{}, processId interface{}) *PerformanceAdvisorApi_ListSuggestedIndexes_Call {
	return &PerformanceAdvisorApi_ListSuggestedIndexes_Call{Call: _e.mock.On("ListSuggestedIndexes", ctx, groupId, processId)}
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexes_Call) Run(run func(ctx context.Context, groupId string, processId string)) *PerformanceAdvisorApi_ListSuggestedIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexes_Call) Return(_a0 admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexes_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// ListSuggestedIndexesExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) ListSuggestedIndexesExecute(r admin.ListSuggestedIndexesApiRequest) (*admin.PerformanceAdvisorResponse, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListSuggestedIndexesExecute")
	}

	var r0 *admin.PerformanceAdvisorResponse
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListSuggestedIndexesApiRequest) (*admin.PerformanceAdvisorResponse, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListSuggestedIndexesApiRequest) *admin.PerformanceAdvisorResponse); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PerformanceAdvisorResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListSuggestedIndexesApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListSuggestedIndexesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSuggestedIndexesExecute'
type PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call struct {
	*mock.Call
}

// ListSuggestedIndexesExecute is a helper method to define mock.On call
//   - r admin.ListSuggestedIndexesApiRequest
func (_e *PerformanceAdvisorApi_Expecter) ListSuggestedIndexesExecute(r interface{}) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call {
	return &PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call{Call: _e.mock.On("ListSuggestedIndexesExecute", r)}
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call) Run(run func(r admin.ListSuggestedIndexesApiRequest)) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListSuggestedIndexesApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call) Return(_a0 *admin.PerformanceAdvisorResponse, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call) RunAndReturn(run func(admin.ListSuggestedIndexesApiRequest) (*admin.PerformanceAdvisorResponse, *http.Response, error)) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListSuggestedIndexesWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) ListSuggestedIndexesWithParams(ctx context.Context, args *admin.ListSuggestedIndexesApiParams) admin.ListSuggestedIndexesApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListSuggestedIndexesWithParams")
	}

	var r0 admin.ListSuggestedIndexesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSuggestedIndexesApiParams) admin.ListSuggestedIndexesApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListSuggestedIndexesApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSuggestedIndexesWithParams'
type PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call struct {
	*mock.Call
}

// ListSuggestedIndexesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListSuggestedIndexesApiParams
func (_e *PerformanceAdvisorApi_Expecter) ListSuggestedIndexesWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call {
	return &PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call{Call: _e.mock.On("ListSuggestedIndexesWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSuggestedIndexesApiParams)) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListSuggestedIndexesApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call) Return(_a0 admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSuggestedIndexesApiParams) admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// SetServerlessAutoIndexing provides a mock function with given fields: ctx, groupId, clusterName
func (_m *PerformanceAdvisorApi) SetServerlessAutoIndexing(ctx context.Context, groupId string, clusterName string) admin.SetServerlessAutoIndexingApiRequest {
	ret := _m.Called(ctx, groupId, clusterName)

	if len(ret) == 0 {
		panic("no return value specified for SetServerlessAutoIndexing")
	}

	var r0 admin.SetServerlessAutoIndexingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.SetServerlessAutoIndexingApiRequest); ok {
		r0 = rf(ctx, groupId, clusterName)
	} else {
		r0 = ret.Get(0).(admin.SetServerlessAutoIndexingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_SetServerlessAutoIndexing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServerlessAutoIndexing'
type PerformanceAdvisorApi_SetServerlessAutoIndexing_Call struct {
	*mock.Call
}

// SetServerlessAutoIndexing is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
func (_e *PerformanceAdvisorApi_Expecter) SetServerlessAutoIndexing(ctx interface{}, groupId interface{}, clusterName interface{}) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call {
	return &PerformanceAdvisorApi_SetServerlessAutoIndexing_Call{Call: _e.mock.On("SetServerlessAutoIndexing", ctx, groupId, clusterName)}
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call) Return(_a0 admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call) RunAndReturn(run func(context.Context, string, string) admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call {
	_c.Call.Return(run)
	return _c
}

// SetServerlessAutoIndexingExecute provides a mock function with given fields: r
func (_m *PerformanceAdvisorApi) SetServerlessAutoIndexingExecute(r admin.SetServerlessAutoIndexingApiRequest) (map[string]interface{}, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for SetServerlessAutoIndexingExecute")
	}

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.SetServerlessAutoIndexingApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.SetServerlessAutoIndexingApiRequest) map[string]interface{}); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(admin.SetServerlessAutoIndexingApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.SetServerlessAutoIndexingApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServerlessAutoIndexingExecute'
type PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call struct {
	*mock.Call
}

// SetServerlessAutoIndexingExecute is a helper method to define mock.On call
//   - r admin.SetServerlessAutoIndexingApiRequest
func (_e *PerformanceAdvisorApi_Expecter) SetServerlessAutoIndexingExecute(r interface{}) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call {
	return &PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call{Call: _e.mock.On("SetServerlessAutoIndexingExecute", r)}
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call) Run(run func(r admin.SetServerlessAutoIndexingApiRequest)) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.SetServerlessAutoIndexingApiRequest))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call) RunAndReturn(run func(admin.SetServerlessAutoIndexingApiRequest) (map[string]interface{}, *http.Response, error)) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// SetServerlessAutoIndexingWithParams provides a mock function with given fields: ctx, args
func (_m *PerformanceAdvisorApi) SetServerlessAutoIndexingWithParams(ctx context.Context, args *admin.SetServerlessAutoIndexingApiParams) admin.SetServerlessAutoIndexingApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for SetServerlessAutoIndexingWithParams")
	}

	var r0 admin.SetServerlessAutoIndexingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.SetServerlessAutoIndexingApiParams) admin.SetServerlessAutoIndexingApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.SetServerlessAutoIndexingApiRequest)
	}

	return r0
}

// PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServerlessAutoIndexingWithParams'
type PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call struct {
	*mock.Call
}

// SetServerlessAutoIndexingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.SetServerlessAutoIndexingApiParams
func (_e *PerformanceAdvisorApi_Expecter) SetServerlessAutoIndexingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call {
	return &PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call{Call: _e.mock.On("SetServerlessAutoIndexingWithParams", ctx, args)}
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call) Run(run func(ctx context.Context, args *admin.SetServerlessAutoIndexingApiParams)) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.SetServerlessAutoIndexingApiParams))
	})
	return _c
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call) Return(_a0 admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call) RunAndReturn(run func(context.Context, *admin.SetServerlessAutoIndexingApiParams) admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewPerformanceAdvisorApi creates a new instance of PerformanceAdvisorApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewPerformanceAdvisorApi(t interface {
	mock.TestingT
	Cleanup(func())
}) *PerformanceAdvisorApi {
	mock := &PerformanceAdvisorApi{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}