atlas_search_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"
)

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

type AtlasSearchApi_Expecter struct {
	mock *mock.Mock
}

func (_m *AtlasSearchApi) EXPECT() *AtlasSearchApi_Expecter {
	return &AtlasSearchApi_Expecter{mock: &_m.Mock}
}

// CreateAtlasSearchDeployment provides a mock function with given fields: ctx, groupId, clusterName, apiSearchDeploymentRequest
func (_m *AtlasSearchApi) CreateAtlasSearchDeployment(ctx context.Context, groupId string, clusterName string, apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest) admin.CreateAtlasSearchDeploymentApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, apiSearchDeploymentRequest)

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

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

	return r0
}

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

// CreateAtlasSearchDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest
func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchDeployment(ctx interface{}, groupId interface{}, clusterName interface{}, apiSearchDeploymentRequest interface{}) *AtlasSearchApi_CreateAtlasSearchDeployment_Call {
	return &AtlasSearchApi_CreateAtlasSearchDeployment_Call{Call: _e.mock.On("CreateAtlasSearchDeployment", ctx, groupId, clusterName, apiSearchDeploymentRequest)}
}

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

func (_c *AtlasSearchApi_CreateAtlasSearchDeployment_Call) Return(_a0 admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeployment_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_CreateAtlasSearchDeployment_Call) RunAndReturn(run func(context.Context, string, string, *admin.ApiSearchDeploymentRequest) admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAtlasSearchDeploymentExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) CreateAtlasSearchDeploymentExecute(r admin.CreateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.CreateAtlasSearchDeploymentApiRequest) *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.CreateAtlasSearchDeploymentApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreateAtlasSearchDeploymentExecute is a helper method to define mock.On call
//   - r admin.CreateAtlasSearchDeploymentApiRequest
func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call {
	return &AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("CreateAtlasSearchDeploymentExecute", r)}
}

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

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

func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.CreateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)) *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) CreateAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.CreateAtlasSearchDeploymentApiParams) admin.CreateAtlasSearchDeploymentApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateAtlasSearchDeploymentWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateAtlasSearchDeploymentApiParams
func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call {
	return &AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("CreateAtlasSearchDeploymentWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateAtlasSearchDeploymentApiParams) admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, clusterSearchIndex
func (_m *AtlasSearchApi) CreateAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, clusterSearchIndex *admin.ClusterSearchIndex) admin.CreateAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, clusterSearchIndex)

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

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

	return r0
}

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

// CreateAtlasSearchIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - clusterSearchIndex *admin.ClusterSearchIndex
func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchIndex(ctx interface{}, groupId interface{}, clusterName interface{}, clusterSearchIndex interface{}) *AtlasSearchApi_CreateAtlasSearchIndex_Call {
	return &AtlasSearchApi_CreateAtlasSearchIndex_Call{Call: _e.mock.On("CreateAtlasSearchIndex", ctx, groupId, clusterName, clusterSearchIndex)}
}

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

func (_c *AtlasSearchApi_CreateAtlasSearchIndex_Call) Return(_a0 admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndex_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_CreateAtlasSearchIndex_Call) RunAndReturn(run func(context.Context, string, string, *admin.ClusterSearchIndex) admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndex_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAtlasSearchIndexExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) CreateAtlasSearchIndexExecute(r admin.CreateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.CreateAtlasSearchIndexApiRequest) *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.CreateAtlasSearchIndexApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreateAtlasSearchIndexExecute is a helper method to define mock.On call
//   - r admin.CreateAtlasSearchIndexApiRequest
func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call {
	return &AtlasSearchApi_CreateAtlasSearchIndexExecute_Call{Call: _e.mock.On("CreateAtlasSearchIndexExecute", r)}
}

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

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

func (_c *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.CreateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) CreateAtlasSearchIndexWithParams(ctx context.Context, args *admin.CreateAtlasSearchIndexApiParams) admin.CreateAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateAtlasSearchIndexWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateAtlasSearchIndexApiParams
func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call {
	return &AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call{Call: _e.mock.On("CreateAtlasSearchIndexWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call) Return(_a0 admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateAtlasSearchIndexApiParams) admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *AtlasSearchApi_DeleteAtlasSearchDeployment_Call) Return(_a0 admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeployment_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchDeploymentApiRequest) (*http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchDeploymentApiRequest) *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.DeleteAtlasSearchDeploymentApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteAtlasSearchDeploymentExecute is a helper method to define mock.On call
//   - r admin.DeleteAtlasSearchDeploymentApiRequest
func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call {
	return &AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("DeleteAtlasSearchDeploymentExecute", r)}
}

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

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

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

// DeleteAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) DeleteAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.DeleteAtlasSearchDeploymentApiParams) admin.DeleteAtlasSearchDeploymentApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteAtlasSearchDeploymentWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteAtlasSearchDeploymentApiParams
func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call {
	return &AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("DeleteAtlasSearchDeploymentWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAtlasSearchDeploymentApiParams) admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, indexId
func (_m *AtlasSearchApi) DeleteAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, indexId string) admin.DeleteAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, indexId)

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

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

	return r0
}

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

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

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

func (_c *AtlasSearchApi_DeleteAtlasSearchIndex_Call) Return(_a0 admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndex_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchIndexApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchIndexApiRequest) 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.DeleteAtlasSearchIndexApiRequest) *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.DeleteAtlasSearchIndexApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeleteAtlasSearchIndexExecute is a helper method to define mock.On call
//   - r admin.DeleteAtlasSearchIndexApiRequest
func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call {
	return &AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call{Call: _e.mock.On("DeleteAtlasSearchIndexExecute", r)}
}

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

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

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

// DeleteAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) DeleteAtlasSearchIndexWithParams(ctx context.Context, args *admin.DeleteAtlasSearchIndexApiParams) admin.DeleteAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteAtlasSearchIndexWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteAtlasSearchIndexApiParams
func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call {
	return &AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call{Call: _e.mock.On("DeleteAtlasSearchIndexWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call) Return(_a0 admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAtlasSearchIndexApiParams) admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *AtlasSearchApi_GetAtlasSearchDeployment_Call) Return(_a0 admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeployment_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetAtlasSearchDeploymentExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) GetAtlasSearchDeploymentExecute(r admin.GetAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetAtlasSearchDeploymentApiRequest) *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.GetAtlasSearchDeploymentApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetAtlasSearchDeploymentExecute is a helper method to define mock.On call
//   - r admin.GetAtlasSearchDeploymentApiRequest
func (_e *AtlasSearchApi_Expecter) GetAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call {
	return &AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("GetAtlasSearchDeploymentExecute", r)}
}

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

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

func (_c *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.GetAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)) *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) GetAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.GetAtlasSearchDeploymentApiParams) admin.GetAtlasSearchDeploymentApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetAtlasSearchDeploymentWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetAtlasSearchDeploymentApiParams
func (_e *AtlasSearchApi_Expecter) GetAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call {
	return &AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("GetAtlasSearchDeploymentWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAtlasSearchDeploymentApiParams) admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, indexId
func (_m *AtlasSearchApi) GetAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, indexId string) admin.GetAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, indexId)

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

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

	return r0
}

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

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

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

func (_c *AtlasSearchApi_GetAtlasSearchIndex_Call) Return(_a0 admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndex_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetAtlasSearchIndexExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) GetAtlasSearchIndexExecute(r admin.GetAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetAtlasSearchIndexApiRequest) *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.GetAtlasSearchIndexApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetAtlasSearchIndexExecute is a helper method to define mock.On call
//   - r admin.GetAtlasSearchIndexApiRequest
func (_e *AtlasSearchApi_Expecter) GetAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_GetAtlasSearchIndexExecute_Call {
	return &AtlasSearchApi_GetAtlasSearchIndexExecute_Call{Call: _e.mock.On("GetAtlasSearchIndexExecute", r)}
}

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

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

func (_c *AtlasSearchApi_GetAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.GetAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_GetAtlasSearchIndexExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) GetAtlasSearchIndexWithParams(ctx context.Context, args *admin.GetAtlasSearchIndexApiParams) admin.GetAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetAtlasSearchIndexWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetAtlasSearchIndexApiParams
func (_e *AtlasSearchApi_Expecter) GetAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call {
	return &AtlasSearchApi_GetAtlasSearchIndexWithParams_Call{Call: _e.mock.On("GetAtlasSearchIndexWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call) Return(_a0 admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAtlasSearchIndexApiParams) admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListAtlasSearchIndexes provides a mock function with given fields: ctx, groupId, clusterName, collectionName, databaseName
func (_m *AtlasSearchApi) ListAtlasSearchIndexes(ctx context.Context, groupId string, clusterName string, collectionName string, databaseName string) admin.ListAtlasSearchIndexesApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, collectionName, databaseName)

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

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

	return r0
}

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

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

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

func (_c *AtlasSearchApi_ListAtlasSearchIndexes_Call) Return(_a0 admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexes_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListAtlasSearchIndexesExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) ListAtlasSearchIndexesExecute(r admin.ListAtlasSearchIndexesApiRequest) ([]admin.ClusterSearchIndex, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.ListAtlasSearchIndexesApiRequest) *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.ListAtlasSearchIndexesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListAtlasSearchIndexesExecute is a helper method to define mock.On call
//   - r admin.ListAtlasSearchIndexesApiRequest
func (_e *AtlasSearchApi_Expecter) ListAtlasSearchIndexesExecute(r interface{}) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call {
	return &AtlasSearchApi_ListAtlasSearchIndexesExecute_Call{Call: _e.mock.On("ListAtlasSearchIndexesExecute", r)}
}

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

func (_c *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call) Return(_a0 []admin.ClusterSearchIndex, _a1 *http.Response, _a2 error) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call) RunAndReturn(run func(admin.ListAtlasSearchIndexesApiRequest) ([]admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListAtlasSearchIndexesWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) ListAtlasSearchIndexesWithParams(ctx context.Context, args *admin.ListAtlasSearchIndexesApiParams) admin.ListAtlasSearchIndexesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListAtlasSearchIndexesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListAtlasSearchIndexesApiParams
func (_e *AtlasSearchApi_Expecter) ListAtlasSearchIndexesWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call {
	return &AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call{Call: _e.mock.On("ListAtlasSearchIndexesWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call) Return(_a0 admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAtlasSearchIndexesApiParams) admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAtlasSearchDeployment provides a mock function with given fields: ctx, groupId, clusterName, apiSearchDeploymentRequest
func (_m *AtlasSearchApi) UpdateAtlasSearchDeployment(ctx context.Context, groupId string, clusterName string, apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest) admin.UpdateAtlasSearchDeploymentApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, apiSearchDeploymentRequest)

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

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

	return r0
}

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

// UpdateAtlasSearchDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest
func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchDeployment(ctx interface{}, groupId interface{}, clusterName interface{}, apiSearchDeploymentRequest interface{}) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call {
	return &AtlasSearchApi_UpdateAtlasSearchDeployment_Call{Call: _e.mock.On("UpdateAtlasSearchDeployment", ctx, groupId, clusterName, apiSearchDeploymentRequest)}
}

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

func (_c *AtlasSearchApi_UpdateAtlasSearchDeployment_Call) Return(_a0 admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_UpdateAtlasSearchDeployment_Call) RunAndReturn(run func(context.Context, string, string, *admin.ApiSearchDeploymentRequest) admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAtlasSearchDeploymentExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) UpdateAtlasSearchDeploymentExecute(r admin.UpdateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.UpdateAtlasSearchDeploymentApiRequest) *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.UpdateAtlasSearchDeploymentApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// UpdateAtlasSearchDeploymentExecute is a helper method to define mock.On call
//   - r admin.UpdateAtlasSearchDeploymentApiRequest
func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call {
	return &AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("UpdateAtlasSearchDeploymentExecute", r)}
}

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

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

func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.UpdateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)) *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) UpdateAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.UpdateAtlasSearchDeploymentApiParams) admin.UpdateAtlasSearchDeploymentApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateAtlasSearchDeploymentWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateAtlasSearchDeploymentApiParams
func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call {
	return &AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("UpdateAtlasSearchDeploymentWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateAtlasSearchDeploymentApiParams) admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, indexId, clusterSearchIndex
func (_m *AtlasSearchApi) UpdateAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, indexId string, clusterSearchIndex *admin.ClusterSearchIndex) admin.UpdateAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, indexId, clusterSearchIndex)

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

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

	return r0
}

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

// UpdateAtlasSearchIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - indexId string
//   - clusterSearchIndex *admin.ClusterSearchIndex
func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchIndex(ctx interface{}, groupId interface{}, clusterName interface{}, indexId interface{}, clusterSearchIndex interface{}) *AtlasSearchApi_UpdateAtlasSearchIndex_Call {
	return &AtlasSearchApi_UpdateAtlasSearchIndex_Call{Call: _e.mock.On("UpdateAtlasSearchIndex", ctx, groupId, clusterName, indexId, clusterSearchIndex)}
}

func (_c *AtlasSearchApi_UpdateAtlasSearchIndex_Call) Run(run func(ctx context.Context, groupId string, clusterName string, indexId string, clusterSearchIndex *admin.ClusterSearchIndex)) *AtlasSearchApi_UpdateAtlasSearchIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*admin.ClusterSearchIndex))
	})
	return _c
}

func (_c *AtlasSearchApi_UpdateAtlasSearchIndex_Call) Return(_a0 admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndex_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_UpdateAtlasSearchIndex_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.ClusterSearchIndex) admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndex_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAtlasSearchIndexExecute provides a mock function with given fields: r
func (_m *AtlasSearchApi) UpdateAtlasSearchIndexExecute(r admin.UpdateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.UpdateAtlasSearchIndexApiRequest) *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.UpdateAtlasSearchIndexApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// UpdateAtlasSearchIndexExecute is a helper method to define mock.On call
//   - r admin.UpdateAtlasSearchIndexApiRequest
func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call {
	return &AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call{Call: _e.mock.On("UpdateAtlasSearchIndexExecute", r)}
}

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

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

func (_c *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.UpdateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args
func (_m *AtlasSearchApi) UpdateAtlasSearchIndexWithParams(ctx context.Context, args *admin.UpdateAtlasSearchIndexApiParams) admin.UpdateAtlasSearchIndexApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateAtlasSearchIndexWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateAtlasSearchIndexApiParams
func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call {
	return &AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call{Call: _e.mock.On("UpdateAtlasSearchIndexWithParams", ctx, args)}
}

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

func (_c *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call) Return(_a0 admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateAtlasSearchIndexApiParams) admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewAtlasSearchApi creates a new instance of AtlasSearchApi. 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 NewAtlasSearchApi(t interface {
	mock.TestingT
	Cleanup(func())
}) *AtlasSearchApi {
	mock := &AtlasSearchApi{}
	mock.Mock.Test(t)

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

	return mock
}