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

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

type ClustersApi_Expecter struct {
	mock *mock.Mock
}

func (_m *ClustersApi) EXPECT() *ClustersApi_Expecter {
	return &ClustersApi_Expecter{mock: &_m.Mock}
}

// CreateCluster provides a mock function with given fields: ctx, groupId, advancedClusterDescription
func (_m *ClustersApi) CreateCluster(ctx context.Context, groupId string, advancedClusterDescription *admin.AdvancedClusterDescription) admin.CreateClusterApiRequest {
	ret := _m.Called(ctx, groupId, advancedClusterDescription)

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

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

	return r0
}

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

// CreateCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - advancedClusterDescription *admin.AdvancedClusterDescription
func (_e *ClustersApi_Expecter) CreateCluster(ctx interface{}, groupId interface{}, advancedClusterDescription interface{}) *ClustersApi_CreateCluster_Call {
	return &ClustersApi_CreateCluster_Call{Call: _e.mock.On("CreateCluster", ctx, groupId, advancedClusterDescription)}
}

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

func (_c *ClustersApi_CreateCluster_Call) Return(_a0 admin.CreateClusterApiRequest) *ClustersApi_CreateCluster_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_CreateCluster_Call) RunAndReturn(run func(context.Context, string, *admin.AdvancedClusterDescription) admin.CreateClusterApiRequest) *ClustersApi_CreateCluster_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClusterExecute provides a mock function with given fields: r
func (_m *ClustersApi) CreateClusterExecute(r admin.CreateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateClusterExecute is a helper method to define mock.On call
//   - r admin.CreateClusterApiRequest
func (_e *ClustersApi_Expecter) CreateClusterExecute(r interface{}) *ClustersApi_CreateClusterExecute_Call {
	return &ClustersApi_CreateClusterExecute_Call{Call: _e.mock.On("CreateClusterExecute", r)}
}

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

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

func (_c *ClustersApi_CreateClusterExecute_Call) RunAndReturn(run func(admin.CreateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)) *ClustersApi_CreateClusterExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClusterWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) CreateClusterWithParams(ctx context.Context, args *admin.CreateClusterApiParams) admin.CreateClusterApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateClusterWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateClusterApiParams
func (_e *ClustersApi_Expecter) CreateClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_CreateClusterWithParams_Call {
	return &ClustersApi_CreateClusterWithParams_Call{Call: _e.mock.On("CreateClusterWithParams", ctx, args)}
}

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

func (_c *ClustersApi_CreateClusterWithParams_Call) Return(_a0 admin.CreateClusterApiRequest) *ClustersApi_CreateClusterWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_CreateClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateClusterApiParams) admin.CreateClusterApiRequest) *ClustersApi_CreateClusterWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_DeleteCluster_Call) Return(_a0 admin.DeleteClusterApiRequest) *ClustersApi_DeleteCluster_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1
}

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

// DeleteClusterExecute is a helper method to define mock.On call
//   - r admin.DeleteClusterApiRequest
func (_e *ClustersApi_Expecter) DeleteClusterExecute(r interface{}) *ClustersApi_DeleteClusterExecute_Call {
	return &ClustersApi_DeleteClusterExecute_Call{Call: _e.mock.On("DeleteClusterExecute", r)}
}

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

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

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

// DeleteClusterWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) DeleteClusterWithParams(ctx context.Context, args *admin.DeleteClusterApiParams) admin.DeleteClusterApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteClusterWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteClusterApiParams
func (_e *ClustersApi_Expecter) DeleteClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_DeleteClusterWithParams_Call {
	return &ClustersApi_DeleteClusterWithParams_Call{Call: _e.mock.On("DeleteClusterWithParams", ctx, args)}
}

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

func (_c *ClustersApi_DeleteClusterWithParams_Call) Return(_a0 admin.DeleteClusterApiRequest) *ClustersApi_DeleteClusterWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_DeleteClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteClusterApiParams) admin.DeleteClusterApiRequest) *ClustersApi_DeleteClusterWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_GetCluster_Call) Return(_a0 admin.GetClusterApiRequest) *ClustersApi_GetCluster_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_GetClusterAdvancedConfiguration_Call) Return(_a0 admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfiguration_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetClusterAdvancedConfigurationExecute provides a mock function with given fields: r
func (_m *ClustersApi) GetClusterAdvancedConfigurationExecute(r admin.GetClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetClusterAdvancedConfigurationExecute is a helper method to define mock.On call
//   - r admin.GetClusterAdvancedConfigurationApiRequest
func (_e *ClustersApi_Expecter) GetClusterAdvancedConfigurationExecute(r interface{}) *ClustersApi_GetClusterAdvancedConfigurationExecute_Call {
	return &ClustersApi_GetClusterAdvancedConfigurationExecute_Call{Call: _e.mock.On("GetClusterAdvancedConfigurationExecute", r)}
}

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

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

func (_c *ClustersApi_GetClusterAdvancedConfigurationExecute_Call) RunAndReturn(run func(admin.GetClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error)) *ClustersApi_GetClusterAdvancedConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterAdvancedConfigurationWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) GetClusterAdvancedConfigurationWithParams(ctx context.Context, args *admin.GetClusterAdvancedConfigurationApiParams) admin.GetClusterAdvancedConfigurationApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetClusterAdvancedConfigurationWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetClusterAdvancedConfigurationApiParams
func (_e *ClustersApi_Expecter) GetClusterAdvancedConfigurationWithParams(ctx interface{}, args interface{}) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call {
	return &ClustersApi_GetClusterAdvancedConfigurationWithParams_Call{Call: _e.mock.On("GetClusterAdvancedConfigurationWithParams", ctx, args)}
}

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

func (_c *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call) Return(_a0 admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetClusterAdvancedConfigurationApiParams) admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterExecute provides a mock function with given fields: r
func (_m *ClustersApi) GetClusterExecute(r admin.GetClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetClusterExecute is a helper method to define mock.On call
//   - r admin.GetClusterApiRequest
func (_e *ClustersApi_Expecter) GetClusterExecute(r interface{}) *ClustersApi_GetClusterExecute_Call {
	return &ClustersApi_GetClusterExecute_Call{Call: _e.mock.On("GetClusterExecute", r)}
}

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

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

func (_c *ClustersApi_GetClusterExecute_Call) RunAndReturn(run func(admin.GetClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)) *ClustersApi_GetClusterExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_GetClusterStatus_Call) Return(_a0 admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetClusterStatusExecute provides a mock function with given fields: r
func (_m *ClustersApi) GetClusterStatusExecute(r admin.GetClusterStatusApiRequest) (*admin.ClusterStatus, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetClusterStatusExecute is a helper method to define mock.On call
//   - r admin.GetClusterStatusApiRequest
func (_e *ClustersApi_Expecter) GetClusterStatusExecute(r interface{}) *ClustersApi_GetClusterStatusExecute_Call {
	return &ClustersApi_GetClusterStatusExecute_Call{Call: _e.mock.On("GetClusterStatusExecute", r)}
}

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

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

func (_c *ClustersApi_GetClusterStatusExecute_Call) RunAndReturn(run func(admin.GetClusterStatusApiRequest) (*admin.ClusterStatus, *http.Response, error)) *ClustersApi_GetClusterStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterStatusWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) GetClusterStatusWithParams(ctx context.Context, args *admin.GetClusterStatusApiParams) admin.GetClusterStatusApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetClusterStatusWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetClusterStatusApiParams
func (_e *ClustersApi_Expecter) GetClusterStatusWithParams(ctx interface{}, args interface{}) *ClustersApi_GetClusterStatusWithParams_Call {
	return &ClustersApi_GetClusterStatusWithParams_Call{Call: _e.mock.On("GetClusterStatusWithParams", ctx, args)}
}

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

func (_c *ClustersApi_GetClusterStatusWithParams_Call) Return(_a0 admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatusWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_GetClusterStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetClusterStatusApiParams) admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatusWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) GetClusterWithParams(ctx context.Context, args *admin.GetClusterApiParams) admin.GetClusterApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetClusterWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetClusterApiParams
func (_e *ClustersApi_Expecter) GetClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_GetClusterWithParams_Call {
	return &ClustersApi_GetClusterWithParams_Call{Call: _e.mock.On("GetClusterWithParams", ctx, args)}
}

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

func (_c *ClustersApi_GetClusterWithParams_Call) Return(_a0 admin.GetClusterApiRequest) *ClustersApi_GetClusterWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_GetClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetClusterApiParams) admin.GetClusterApiRequest) *ClustersApi_GetClusterWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetSampleDatasetLoadStatus provides a mock function with given fields: ctx, groupId, sampleDatasetId
func (_m *ClustersApi) GetSampleDatasetLoadStatus(ctx context.Context, groupId string, sampleDatasetId string) admin.GetSampleDatasetLoadStatusApiRequest {
	ret := _m.Called(ctx, groupId, sampleDatasetId)

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_GetSampleDatasetLoadStatus_Call) Return(_a0 admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetSampleDatasetLoadStatusExecute provides a mock function with given fields: r
func (_m *ClustersApi) GetSampleDatasetLoadStatusExecute(r admin.GetSampleDatasetLoadStatusApiRequest) (*admin.SampleDatasetStatus, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetSampleDatasetLoadStatusExecute is a helper method to define mock.On call
//   - r admin.GetSampleDatasetLoadStatusApiRequest
func (_e *ClustersApi_Expecter) GetSampleDatasetLoadStatusExecute(r interface{}) *ClustersApi_GetSampleDatasetLoadStatusExecute_Call {
	return &ClustersApi_GetSampleDatasetLoadStatusExecute_Call{Call: _e.mock.On("GetSampleDatasetLoadStatusExecute", r)}
}

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

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

func (_c *ClustersApi_GetSampleDatasetLoadStatusExecute_Call) RunAndReturn(run func(admin.GetSampleDatasetLoadStatusApiRequest) (*admin.SampleDatasetStatus, *http.Response, error)) *ClustersApi_GetSampleDatasetLoadStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetSampleDatasetLoadStatusWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) GetSampleDatasetLoadStatusWithParams(ctx context.Context, args *admin.GetSampleDatasetLoadStatusApiParams) admin.GetSampleDatasetLoadStatusApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetSampleDatasetLoadStatusWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetSampleDatasetLoadStatusApiParams
func (_e *ClustersApi_Expecter) GetSampleDatasetLoadStatusWithParams(ctx interface{}, args interface{}) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call {
	return &ClustersApi_GetSampleDatasetLoadStatusWithParams_Call{Call: _e.mock.On("GetSampleDatasetLoadStatusWithParams", ctx, args)}
}

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

func (_c *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call) Return(_a0 admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetSampleDatasetLoadStatusApiParams) admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_ListCloudProviderRegions_Call) Return(_a0 admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegions_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListCloudProviderRegionsExecute provides a mock function with given fields: r
func (_m *ClustersApi) ListCloudProviderRegionsExecute(r admin.ListCloudProviderRegionsApiRequest) (*admin.PaginatedApiAtlasProviderRegions, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListCloudProviderRegionsExecute is a helper method to define mock.On call
//   - r admin.ListCloudProviderRegionsApiRequest
func (_e *ClustersApi_Expecter) ListCloudProviderRegionsExecute(r interface{}) *ClustersApi_ListCloudProviderRegionsExecute_Call {
	return &ClustersApi_ListCloudProviderRegionsExecute_Call{Call: _e.mock.On("ListCloudProviderRegionsExecute", r)}
}

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

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

func (_c *ClustersApi_ListCloudProviderRegionsExecute_Call) RunAndReturn(run func(admin.ListCloudProviderRegionsApiRequest) (*admin.PaginatedApiAtlasProviderRegions, *http.Response, error)) *ClustersApi_ListCloudProviderRegionsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListCloudProviderRegionsWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) ListCloudProviderRegionsWithParams(ctx context.Context, args *admin.ListCloudProviderRegionsApiParams) admin.ListCloudProviderRegionsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListCloudProviderRegionsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListCloudProviderRegionsApiParams
func (_e *ClustersApi_Expecter) ListCloudProviderRegionsWithParams(ctx interface{}, args interface{}) *ClustersApi_ListCloudProviderRegionsWithParams_Call {
	return &ClustersApi_ListCloudProviderRegionsWithParams_Call{Call: _e.mock.On("ListCloudProviderRegionsWithParams", ctx, args)}
}

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

func (_c *ClustersApi_ListCloudProviderRegionsWithParams_Call) Return(_a0 admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegionsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_ListCloudProviderRegionsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListCloudProviderRegionsApiParams) admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegionsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_ListClusters_Call) Return(_a0 admin.ListClustersApiRequest) *ClustersApi_ListClusters_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListClustersExecute provides a mock function with given fields: r
func (_m *ClustersApi) ListClustersExecute(r admin.ListClustersApiRequest) (*admin.PaginatedAdvancedClusterDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListClustersExecute is a helper method to define mock.On call
//   - r admin.ListClustersApiRequest
func (_e *ClustersApi_Expecter) ListClustersExecute(r interface{}) *ClustersApi_ListClustersExecute_Call {
	return &ClustersApi_ListClustersExecute_Call{Call: _e.mock.On("ListClustersExecute", r)}
}

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

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

func (_c *ClustersApi_ListClustersExecute_Call) RunAndReturn(run func(admin.ListClustersApiRequest) (*admin.PaginatedAdvancedClusterDescription, *http.Response, error)) *ClustersApi_ListClustersExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListClustersForAllProjects provides a mock function with given fields: ctx
func (_m *ClustersApi) ListClustersForAllProjects(ctx context.Context) admin.ListClustersForAllProjectsApiRequest {
	ret := _m.Called(ctx)

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

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

	return r0
}

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

// ListClustersForAllProjects is a helper method to define mock.On call
//   - ctx context.Context
func (_e *ClustersApi_Expecter) ListClustersForAllProjects(ctx interface{}) *ClustersApi_ListClustersForAllProjects_Call {
	return &ClustersApi_ListClustersForAllProjects_Call{Call: _e.mock.On("ListClustersForAllProjects", ctx)}
}

func (_c *ClustersApi_ListClustersForAllProjects_Call) Run(run func(ctx context.Context)) *ClustersApi_ListClustersForAllProjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ClustersApi_ListClustersForAllProjects_Call) Return(_a0 admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_ListClustersForAllProjects_Call) RunAndReturn(run func(context.Context) admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjects_Call {
	_c.Call.Return(run)
	return _c
}

// ListClustersForAllProjectsExecute provides a mock function with given fields: r
func (_m *ClustersApi) ListClustersForAllProjectsExecute(r admin.ListClustersForAllProjectsApiRequest) (*admin.PaginatedOrgGroup, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListClustersForAllProjectsExecute is a helper method to define mock.On call
//   - r admin.ListClustersForAllProjectsApiRequest
func (_e *ClustersApi_Expecter) ListClustersForAllProjectsExecute(r interface{}) *ClustersApi_ListClustersForAllProjectsExecute_Call {
	return &ClustersApi_ListClustersForAllProjectsExecute_Call{Call: _e.mock.On("ListClustersForAllProjectsExecute", r)}
}

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

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

func (_c *ClustersApi_ListClustersForAllProjectsExecute_Call) RunAndReturn(run func(admin.ListClustersForAllProjectsApiRequest) (*admin.PaginatedOrgGroup, *http.Response, error)) *ClustersApi_ListClustersForAllProjectsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListClustersForAllProjectsWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) ListClustersForAllProjectsWithParams(ctx context.Context, args *admin.ListClustersForAllProjectsApiParams) admin.ListClustersForAllProjectsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListClustersForAllProjectsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListClustersForAllProjectsApiParams
func (_e *ClustersApi_Expecter) ListClustersForAllProjectsWithParams(ctx interface{}, args interface{}) *ClustersApi_ListClustersForAllProjectsWithParams_Call {
	return &ClustersApi_ListClustersForAllProjectsWithParams_Call{Call: _e.mock.On("ListClustersForAllProjectsWithParams", ctx, args)}
}

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

func (_c *ClustersApi_ListClustersForAllProjectsWithParams_Call) Return(_a0 admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjectsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_ListClustersForAllProjectsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListClustersForAllProjectsApiParams) admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjectsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListClustersWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) ListClustersWithParams(ctx context.Context, args *admin.ListClustersApiParams) admin.ListClustersApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListClustersWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListClustersApiParams
func (_e *ClustersApi_Expecter) ListClustersWithParams(ctx interface{}, args interface{}) *ClustersApi_ListClustersWithParams_Call {
	return &ClustersApi_ListClustersWithParams_Call{Call: _e.mock.On("ListClustersWithParams", ctx, args)}
}

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

func (_c *ClustersApi_ListClustersWithParams_Call) Return(_a0 admin.ListClustersApiRequest) *ClustersApi_ListClustersWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_ListClustersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListClustersApiParams) admin.ListClustersApiRequest) *ClustersApi_ListClustersWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// LoadSampleDataset provides a mock function with given fields: ctx, groupId, name
func (_m *ClustersApi) LoadSampleDataset(ctx context.Context, groupId string, name string) admin.LoadSampleDatasetApiRequest {
	ret := _m.Called(ctx, groupId, name)

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_LoadSampleDataset_Call) Return(_a0 admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDataset_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// LoadSampleDatasetExecute provides a mock function with given fields: r
func (_m *ClustersApi) LoadSampleDatasetExecute(r admin.LoadSampleDatasetApiRequest) (*admin.SampleDatasetStatus, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// LoadSampleDatasetExecute is a helper method to define mock.On call
//   - r admin.LoadSampleDatasetApiRequest
func (_e *ClustersApi_Expecter) LoadSampleDatasetExecute(r interface{}) *ClustersApi_LoadSampleDatasetExecute_Call {
	return &ClustersApi_LoadSampleDatasetExecute_Call{Call: _e.mock.On("LoadSampleDatasetExecute", r)}
}

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

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

func (_c *ClustersApi_LoadSampleDatasetExecute_Call) RunAndReturn(run func(admin.LoadSampleDatasetApiRequest) (*admin.SampleDatasetStatus, *http.Response, error)) *ClustersApi_LoadSampleDatasetExecute_Call {
	_c.Call.Return(run)
	return _c
}

// LoadSampleDatasetWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) LoadSampleDatasetWithParams(ctx context.Context, args *admin.LoadSampleDatasetApiParams) admin.LoadSampleDatasetApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// LoadSampleDatasetWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.LoadSampleDatasetApiParams
func (_e *ClustersApi_Expecter) LoadSampleDatasetWithParams(ctx interface{}, args interface{}) *ClustersApi_LoadSampleDatasetWithParams_Call {
	return &ClustersApi_LoadSampleDatasetWithParams_Call{Call: _e.mock.On("LoadSampleDatasetWithParams", ctx, args)}
}

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

func (_c *ClustersApi_LoadSampleDatasetWithParams_Call) Return(_a0 admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDatasetWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_LoadSampleDatasetWithParams_Call) RunAndReturn(run func(context.Context, *admin.LoadSampleDatasetApiParams) admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDatasetWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ClustersApi_TestFailover_Call) Return(_a0 admin.TestFailoverApiRequest) *ClustersApi_TestFailover_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1
}

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

// TestFailoverExecute is a helper method to define mock.On call
//   - r admin.TestFailoverApiRequest
func (_e *ClustersApi_Expecter) TestFailoverExecute(r interface{}) *ClustersApi_TestFailoverExecute_Call {
	return &ClustersApi_TestFailoverExecute_Call{Call: _e.mock.On("TestFailoverExecute", r)}
}

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

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

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

// TestFailoverWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) TestFailoverWithParams(ctx context.Context, args *admin.TestFailoverApiParams) admin.TestFailoverApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// TestFailoverWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.TestFailoverApiParams
func (_e *ClustersApi_Expecter) TestFailoverWithParams(ctx interface{}, args interface{}) *ClustersApi_TestFailoverWithParams_Call {
	return &ClustersApi_TestFailoverWithParams_Call{Call: _e.mock.On("TestFailoverWithParams", ctx, args)}
}

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

func (_c *ClustersApi_TestFailoverWithParams_Call) Return(_a0 admin.TestFailoverApiRequest) *ClustersApi_TestFailoverWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_TestFailoverWithParams_Call) RunAndReturn(run func(context.Context, *admin.TestFailoverApiParams) admin.TestFailoverApiRequest) *ClustersApi_TestFailoverWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateCluster provides a mock function with given fields: ctx, groupId, clusterName, advancedClusterDescription
func (_m *ClustersApi) UpdateCluster(ctx context.Context, groupId string, clusterName string, advancedClusterDescription *admin.AdvancedClusterDescription) admin.UpdateClusterApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, advancedClusterDescription)

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

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

	return r0
}

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

// UpdateCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - advancedClusterDescription *admin.AdvancedClusterDescription
func (_e *ClustersApi_Expecter) UpdateCluster(ctx interface{}, groupId interface{}, clusterName interface{}, advancedClusterDescription interface{}) *ClustersApi_UpdateCluster_Call {
	return &ClustersApi_UpdateCluster_Call{Call: _e.mock.On("UpdateCluster", ctx, groupId, clusterName, advancedClusterDescription)}
}

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

func (_c *ClustersApi_UpdateCluster_Call) Return(_a0 admin.UpdateClusterApiRequest) *ClustersApi_UpdateCluster_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpdateCluster_Call) RunAndReturn(run func(context.Context, string, string, *admin.AdvancedClusterDescription) admin.UpdateClusterApiRequest) *ClustersApi_UpdateCluster_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterAdvancedConfiguration provides a mock function with given fields: ctx, groupId, clusterName, clusterDescriptionProcessArgs
func (_m *ClustersApi) UpdateClusterAdvancedConfiguration(ctx context.Context, groupId string, clusterName string, clusterDescriptionProcessArgs *admin.ClusterDescriptionProcessArgs) admin.UpdateClusterAdvancedConfigurationApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, clusterDescriptionProcessArgs)

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

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

	return r0
}

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

// UpdateClusterAdvancedConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - clusterDescriptionProcessArgs *admin.ClusterDescriptionProcessArgs
func (_e *ClustersApi_Expecter) UpdateClusterAdvancedConfiguration(ctx interface{}, groupId interface{}, clusterName interface{}, clusterDescriptionProcessArgs interface{}) *ClustersApi_UpdateClusterAdvancedConfiguration_Call {
	return &ClustersApi_UpdateClusterAdvancedConfiguration_Call{Call: _e.mock.On("UpdateClusterAdvancedConfiguration", ctx, groupId, clusterName, clusterDescriptionProcessArgs)}
}

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

func (_c *ClustersApi_UpdateClusterAdvancedConfiguration_Call) Return(_a0 admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfiguration_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpdateClusterAdvancedConfiguration_Call) RunAndReturn(run func(context.Context, string, string, *admin.ClusterDescriptionProcessArgs) admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterAdvancedConfigurationExecute provides a mock function with given fields: r
func (_m *ClustersApi) UpdateClusterAdvancedConfigurationExecute(r admin.UpdateClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateClusterAdvancedConfigurationExecute is a helper method to define mock.On call
//   - r admin.UpdateClusterAdvancedConfigurationApiRequest
func (_e *ClustersApi_Expecter) UpdateClusterAdvancedConfigurationExecute(r interface{}) *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call {
	return &ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call{Call: _e.mock.On("UpdateClusterAdvancedConfigurationExecute", r)}
}

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

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

func (_c *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call) RunAndReturn(run func(admin.UpdateClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error)) *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterAdvancedConfigurationWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) UpdateClusterAdvancedConfigurationWithParams(ctx context.Context, args *admin.UpdateClusterAdvancedConfigurationApiParams) admin.UpdateClusterAdvancedConfigurationApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateClusterAdvancedConfigurationWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateClusterAdvancedConfigurationApiParams
func (_e *ClustersApi_Expecter) UpdateClusterAdvancedConfigurationWithParams(ctx interface{}, args interface{}) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call {
	return &ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call{Call: _e.mock.On("UpdateClusterAdvancedConfigurationWithParams", ctx, args)}
}

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

func (_c *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call) Return(_a0 admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateClusterAdvancedConfigurationApiParams) admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterExecute provides a mock function with given fields: r
func (_m *ClustersApi) UpdateClusterExecute(r admin.UpdateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateClusterExecute is a helper method to define mock.On call
//   - r admin.UpdateClusterApiRequest
func (_e *ClustersApi_Expecter) UpdateClusterExecute(r interface{}) *ClustersApi_UpdateClusterExecute_Call {
	return &ClustersApi_UpdateClusterExecute_Call{Call: _e.mock.On("UpdateClusterExecute", r)}
}

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

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

func (_c *ClustersApi_UpdateClusterExecute_Call) RunAndReturn(run func(admin.UpdateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)) *ClustersApi_UpdateClusterExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) UpdateClusterWithParams(ctx context.Context, args *admin.UpdateClusterApiParams) admin.UpdateClusterApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateClusterWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateClusterApiParams
func (_e *ClustersApi_Expecter) UpdateClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_UpdateClusterWithParams_Call {
	return &ClustersApi_UpdateClusterWithParams_Call{Call: _e.mock.On("UpdateClusterWithParams", ctx, args)}
}

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

func (_c *ClustersApi_UpdateClusterWithParams_Call) Return(_a0 admin.UpdateClusterApiRequest) *ClustersApi_UpdateClusterWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpdateClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateClusterApiParams) admin.UpdateClusterApiRequest) *ClustersApi_UpdateClusterWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeSharedCluster provides a mock function with given fields: ctx, groupId, legacyAtlasTenantClusterUpgradeRequest
func (_m *ClustersApi) UpgradeSharedCluster(ctx context.Context, groupId string, legacyAtlasTenantClusterUpgradeRequest *admin.LegacyAtlasTenantClusterUpgradeRequest) admin.UpgradeSharedClusterApiRequest {
	ret := _m.Called(ctx, groupId, legacyAtlasTenantClusterUpgradeRequest)

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

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

	return r0
}

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

// UpgradeSharedCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - legacyAtlasTenantClusterUpgradeRequest *admin.LegacyAtlasTenantClusterUpgradeRequest
func (_e *ClustersApi_Expecter) UpgradeSharedCluster(ctx interface{}, groupId interface{}, legacyAtlasTenantClusterUpgradeRequest interface{}) *ClustersApi_UpgradeSharedCluster_Call {
	return &ClustersApi_UpgradeSharedCluster_Call{Call: _e.mock.On("UpgradeSharedCluster", ctx, groupId, legacyAtlasTenantClusterUpgradeRequest)}
}

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

func (_c *ClustersApi_UpgradeSharedCluster_Call) Return(_a0 admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedCluster_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpgradeSharedCluster_Call) RunAndReturn(run func(context.Context, string, *admin.LegacyAtlasTenantClusterUpgradeRequest) admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedCluster_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeSharedClusterExecute provides a mock function with given fields: r
func (_m *ClustersApi) UpgradeSharedClusterExecute(r admin.UpgradeSharedClusterApiRequest) (*admin.LegacyAtlasCluster, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpgradeSharedClusterExecute is a helper method to define mock.On call
//   - r admin.UpgradeSharedClusterApiRequest
func (_e *ClustersApi_Expecter) UpgradeSharedClusterExecute(r interface{}) *ClustersApi_UpgradeSharedClusterExecute_Call {
	return &ClustersApi_UpgradeSharedClusterExecute_Call{Call: _e.mock.On("UpgradeSharedClusterExecute", r)}
}

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

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

func (_c *ClustersApi_UpgradeSharedClusterExecute_Call) RunAndReturn(run func(admin.UpgradeSharedClusterApiRequest) (*admin.LegacyAtlasCluster, *http.Response, error)) *ClustersApi_UpgradeSharedClusterExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeSharedClusterToServerless provides a mock function with given fields: ctx, groupId, serverlessInstanceDescription
func (_m *ClustersApi) UpgradeSharedClusterToServerless(ctx context.Context, groupId string, serverlessInstanceDescription *admin.ServerlessInstanceDescription) admin.UpgradeSharedClusterToServerlessApiRequest {
	ret := _m.Called(ctx, groupId, serverlessInstanceDescription)

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

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

	return r0
}

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

// UpgradeSharedClusterToServerless is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - serverlessInstanceDescription *admin.ServerlessInstanceDescription
func (_e *ClustersApi_Expecter) UpgradeSharedClusterToServerless(ctx interface{}, groupId interface{}, serverlessInstanceDescription interface{}) *ClustersApi_UpgradeSharedClusterToServerless_Call {
	return &ClustersApi_UpgradeSharedClusterToServerless_Call{Call: _e.mock.On("UpgradeSharedClusterToServerless", ctx, groupId, serverlessInstanceDescription)}
}

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

func (_c *ClustersApi_UpgradeSharedClusterToServerless_Call) Return(_a0 admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerless_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpgradeSharedClusterToServerless_Call) RunAndReturn(run func(context.Context, string, *admin.ServerlessInstanceDescription) admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerless_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeSharedClusterToServerlessExecute provides a mock function with given fields: r
func (_m *ClustersApi) UpgradeSharedClusterToServerlessExecute(r admin.UpgradeSharedClusterToServerlessApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpgradeSharedClusterToServerlessExecute is a helper method to define mock.On call
//   - r admin.UpgradeSharedClusterToServerlessApiRequest
func (_e *ClustersApi_Expecter) UpgradeSharedClusterToServerlessExecute(r interface{}) *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call {
	return &ClustersApi_UpgradeSharedClusterToServerlessExecute_Call{Call: _e.mock.On("UpgradeSharedClusterToServerlessExecute", r)}
}

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

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

func (_c *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call) RunAndReturn(run func(admin.UpgradeSharedClusterToServerlessApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeSharedClusterToServerlessWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) UpgradeSharedClusterToServerlessWithParams(ctx context.Context, args *admin.UpgradeSharedClusterToServerlessApiParams) admin.UpgradeSharedClusterToServerlessApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpgradeSharedClusterToServerlessWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpgradeSharedClusterToServerlessApiParams
func (_e *ClustersApi_Expecter) UpgradeSharedClusterToServerlessWithParams(ctx interface{}, args interface{}) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call {
	return &ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call{Call: _e.mock.On("UpgradeSharedClusterToServerlessWithParams", ctx, args)}
}

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

func (_c *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call) Return(_a0 admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpgradeSharedClusterToServerlessApiParams) admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeSharedClusterWithParams provides a mock function with given fields: ctx, args
func (_m *ClustersApi) UpgradeSharedClusterWithParams(ctx context.Context, args *admin.UpgradeSharedClusterApiParams) admin.UpgradeSharedClusterApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpgradeSharedClusterWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpgradeSharedClusterApiParams
func (_e *ClustersApi_Expecter) UpgradeSharedClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_UpgradeSharedClusterWithParams_Call {
	return &ClustersApi_UpgradeSharedClusterWithParams_Call{Call: _e.mock.On("UpgradeSharedClusterWithParams", ctx, args)}
}

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

func (_c *ClustersApi_UpgradeSharedClusterWithParams_Call) Return(_a0 admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedClusterWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClustersApi_UpgradeSharedClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpgradeSharedClusterApiParams) admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedClusterWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}