mock_clusters_interface.go

// Code generated by mockery v2.39.1. DO NOT EDIT.

package compute

import (
	context "context"

	compute "github.com/databricks/databricks-sdk-go/service/compute"

	listing "github.com/databricks/databricks-sdk-go/listing"

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

	retries "github.com/databricks/databricks-sdk-go/retries"

	time "time"
)

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

type MockClustersInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClustersInterface) EXPECT() *MockClustersInterface_Expecter {
	return &MockClustersInterface_Expecter{mock: &_m.Mock}
}

// ChangeOwner provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) ChangeOwner(ctx context.Context, request compute.ChangeClusterOwner) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ChangeClusterOwner) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ChangeOwner is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.ChangeClusterOwner
func (_e *MockClustersInterface_Expecter) ChangeOwner(ctx interface{}, request interface{}) *MockClustersInterface_ChangeOwner_Call {
	return &MockClustersInterface_ChangeOwner_Call{Call: _e.mock.On("ChangeOwner", ctx, request)}
}

func (_c *MockClustersInterface_ChangeOwner_Call) Run(run func(ctx context.Context, request compute.ChangeClusterOwner)) *MockClustersInterface_ChangeOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ChangeClusterOwner))
	})
	return _c
}

func (_c *MockClustersInterface_ChangeOwner_Call) Return(_a0 error) *MockClustersInterface_ChangeOwner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_ChangeOwner_Call) RunAndReturn(run func(context.Context, compute.ChangeClusterOwner) error) *MockClustersInterface_ChangeOwner_Call {
	_c.Call.Return(run)
	return _c
}

// ClusterDetailsClusterNameToClusterIdMap provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) ClusterDetailsClusterNameToClusterIdMap(ctx context.Context, request compute.ListClustersRequest) (map[string]string, error) {
	ret := _m.Called(ctx, request)

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

	var r0 map[string]string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ListClustersRequest) (map[string]string, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.ListClustersRequest) map[string]string); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.ListClustersRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ClusterDetailsClusterNameToClusterIdMap is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.ListClustersRequest
func (_e *MockClustersInterface_Expecter) ClusterDetailsClusterNameToClusterIdMap(ctx interface{}, request interface{}) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call {
	return &MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call{Call: _e.mock.On("ClusterDetailsClusterNameToClusterIdMap", ctx, request)}
}

func (_c *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) Run(run func(ctx context.Context, request compute.ListClustersRequest)) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ListClustersRequest))
	})
	return _c
}

func (_c *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) Return(_a0 map[string]string, _a1 error) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) RunAndReturn(run func(context.Context, compute.ListClustersRequest) (map[string]string, error)) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function with given fields: ctx, createCluster
func (_m *MockClustersInterface) Create(ctx context.Context, createCluster compute.CreateCluster) (*compute.WaitGetClusterRunning[compute.CreateClusterResponse], error) {
	ret := _m.Called(ctx, createCluster)

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

	var r0 *compute.WaitGetClusterRunning[compute.CreateClusterResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.CreateCluster) (*compute.WaitGetClusterRunning[compute.CreateClusterResponse], error)); ok {
		return rf(ctx, createCluster)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.CreateCluster) *compute.WaitGetClusterRunning[compute.CreateClusterResponse]); ok {
		r0 = rf(ctx, createCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.WaitGetClusterRunning[compute.CreateClusterResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.CreateCluster) error); ok {
		r1 = rf(ctx, createCluster)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - createCluster compute.CreateCluster
func (_e *MockClustersInterface_Expecter) Create(ctx interface{}, createCluster interface{}) *MockClustersInterface_Create_Call {
	return &MockClustersInterface_Create_Call{Call: _e.mock.On("Create", ctx, createCluster)}
}

func (_c *MockClustersInterface_Create_Call) Run(run func(ctx context.Context, createCluster compute.CreateCluster)) *MockClustersInterface_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.CreateCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Create_Call) Return(_a0 *compute.WaitGetClusterRunning[compute.CreateClusterResponse], _a1 error) *MockClustersInterface_Create_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Create_Call) RunAndReturn(run func(context.Context, compute.CreateCluster) (*compute.WaitGetClusterRunning[compute.CreateClusterResponse], error)) *MockClustersInterface_Create_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAndWait provides a mock function with given fields: ctx, createCluster, options
func (_m *MockClustersInterface) CreateAndWait(ctx context.Context, createCluster compute.CreateCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, createCluster)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.CreateCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, createCluster, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.CreateCluster, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, createCluster, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.CreateCluster, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, createCluster, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - createCluster compute.CreateCluster
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) CreateAndWait(ctx interface{}, createCluster interface{}, options ...interface{}) *MockClustersInterface_CreateAndWait_Call {
	return &MockClustersInterface_CreateAndWait_Call{Call: _e.mock.On("CreateAndWait",
		append([]interface{}{ctx, createCluster}, options...)...)}
}

func (_c *MockClustersInterface_CreateAndWait_Call) Run(run func(ctx context.Context, createCluster compute.CreateCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_CreateAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(compute.CreateCluster), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_CreateAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_CreateAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_CreateAndWait_Call) RunAndReturn(run func(context.Context, compute.CreateCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_CreateAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: ctx, deleteCluster
func (_m *MockClustersInterface) Delete(ctx context.Context, deleteCluster compute.DeleteCluster) (*compute.WaitGetClusterTerminated[struct{}], error) {
	ret := _m.Called(ctx, deleteCluster)

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

	var r0 *compute.WaitGetClusterTerminated[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.DeleteCluster) (*compute.WaitGetClusterTerminated[struct{}], error)); ok {
		return rf(ctx, deleteCluster)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.DeleteCluster) *compute.WaitGetClusterTerminated[struct{}]); ok {
		r0 = rf(ctx, deleteCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.WaitGetClusterTerminated[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.DeleteCluster) error); ok {
		r1 = rf(ctx, deleteCluster)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - deleteCluster compute.DeleteCluster
func (_e *MockClustersInterface_Expecter) Delete(ctx interface{}, deleteCluster interface{}) *MockClustersInterface_Delete_Call {
	return &MockClustersInterface_Delete_Call{Call: _e.mock.On("Delete", ctx, deleteCluster)}
}

func (_c *MockClustersInterface_Delete_Call) Run(run func(ctx context.Context, deleteCluster compute.DeleteCluster)) *MockClustersInterface_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.DeleteCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Delete_Call) Return(_a0 *compute.WaitGetClusterTerminated[struct{}], _a1 error) *MockClustersInterface_Delete_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Delete_Call) RunAndReturn(run func(context.Context, compute.DeleteCluster) (*compute.WaitGetClusterTerminated[struct{}], error)) *MockClustersInterface_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAndWait provides a mock function with given fields: ctx, deleteCluster, options
func (_m *MockClustersInterface) DeleteAndWait(ctx context.Context, deleteCluster compute.DeleteCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, deleteCluster)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.DeleteCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, deleteCluster, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.DeleteCluster, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, deleteCluster, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.DeleteCluster, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, deleteCluster, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - deleteCluster compute.DeleteCluster
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) DeleteAndWait(ctx interface{}, deleteCluster interface{}, options ...interface{}) *MockClustersInterface_DeleteAndWait_Call {
	return &MockClustersInterface_DeleteAndWait_Call{Call: _e.mock.On("DeleteAndWait",
		append([]interface{}{ctx, deleteCluster}, options...)...)}
}

func (_c *MockClustersInterface_DeleteAndWait_Call) Run(run func(ctx context.Context, deleteCluster compute.DeleteCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_DeleteAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(compute.DeleteCluster), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_DeleteAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_DeleteAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_DeleteAndWait_Call) RunAndReturn(run func(context.Context, compute.DeleteCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_DeleteAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) DeleteByClusterId(ctx context.Context, clusterId string) error {
	ret := _m.Called(ctx, clusterId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, clusterId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) DeleteByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_DeleteByClusterId_Call {
	return &MockClustersInterface_DeleteByClusterId_Call{Call: _e.mock.On("DeleteByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_DeleteByClusterId_Call) Return(_a0 error) *MockClustersInterface_DeleteByClusterId_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_DeleteByClusterId_Call) RunAndReturn(run func(context.Context, string) error) *MockClustersInterface_DeleteByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteByClusterIdAndWait provides a mock function with given fields: ctx, clusterId, options
func (_m *MockClustersInterface) DeleteByClusterIdAndWait(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, clusterId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, clusterId, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, clusterId, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, clusterId, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteByClusterIdAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) DeleteByClusterIdAndWait(ctx interface{}, clusterId interface{}, options ...interface{}) *MockClustersInterface_DeleteByClusterIdAndWait_Call {
	return &MockClustersInterface_DeleteByClusterIdAndWait_Call{Call: _e.mock.On("DeleteByClusterIdAndWait",
		append([]interface{}{ctx, clusterId}, options...)...)}
}

func (_c *MockClustersInterface_DeleteByClusterIdAndWait_Call) Run(run func(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_DeleteByClusterIdAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_DeleteByClusterIdAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_DeleteByClusterIdAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_DeleteByClusterIdAndWait_Call) RunAndReturn(run func(context.Context, string, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_DeleteByClusterIdAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// Edit provides a mock function with given fields: ctx, editCluster
func (_m *MockClustersInterface) Edit(ctx context.Context, editCluster compute.EditCluster) (*compute.WaitGetClusterRunning[struct{}], error) {
	ret := _m.Called(ctx, editCluster)

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

	var r0 *compute.WaitGetClusterRunning[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.EditCluster) (*compute.WaitGetClusterRunning[struct{}], error)); ok {
		return rf(ctx, editCluster)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.EditCluster) *compute.WaitGetClusterRunning[struct{}]); ok {
		r0 = rf(ctx, editCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.WaitGetClusterRunning[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.EditCluster) error); ok {
		r1 = rf(ctx, editCluster)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Edit is a helper method to define mock.On call
//   - ctx context.Context
//   - editCluster compute.EditCluster
func (_e *MockClustersInterface_Expecter) Edit(ctx interface{}, editCluster interface{}) *MockClustersInterface_Edit_Call {
	return &MockClustersInterface_Edit_Call{Call: _e.mock.On("Edit", ctx, editCluster)}
}

func (_c *MockClustersInterface_Edit_Call) Run(run func(ctx context.Context, editCluster compute.EditCluster)) *MockClustersInterface_Edit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.EditCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Edit_Call) Return(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 error) *MockClustersInterface_Edit_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Edit_Call) RunAndReturn(run func(context.Context, compute.EditCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Edit_Call {
	_c.Call.Return(run)
	return _c
}

// EditAndWait provides a mock function with given fields: ctx, editCluster, options
func (_m *MockClustersInterface) EditAndWait(ctx context.Context, editCluster compute.EditCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, editCluster)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.EditCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, editCluster, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.EditCluster, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, editCluster, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.EditCluster, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, editCluster, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// EditAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - editCluster compute.EditCluster
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) EditAndWait(ctx interface{}, editCluster interface{}, options ...interface{}) *MockClustersInterface_EditAndWait_Call {
	return &MockClustersInterface_EditAndWait_Call{Call: _e.mock.On("EditAndWait",
		append([]interface{}{ctx, editCluster}, options...)...)}
}

func (_c *MockClustersInterface_EditAndWait_Call) Run(run func(ctx context.Context, editCluster compute.EditCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_EditAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(compute.EditCluster), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_EditAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_EditAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_EditAndWait_Call) RunAndReturn(run func(context.Context, compute.EditCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_EditAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// EnsureClusterIsRunning provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) EnsureClusterIsRunning(ctx context.Context, clusterId string) error {
	ret := _m.Called(ctx, clusterId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, clusterId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// EnsureClusterIsRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) EnsureClusterIsRunning(ctx interface{}, clusterId interface{}) *MockClustersInterface_EnsureClusterIsRunning_Call {
	return &MockClustersInterface_EnsureClusterIsRunning_Call{Call: _e.mock.On("EnsureClusterIsRunning", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_EnsureClusterIsRunning_Call) Return(_a0 error) *MockClustersInterface_EnsureClusterIsRunning_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_EnsureClusterIsRunning_Call) RunAndReturn(run func(context.Context, string) error) *MockClustersInterface_EnsureClusterIsRunning_Call {
	_c.Call.Return(run)
	return _c
}

// Events provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) Events(ctx context.Context, request compute.GetEvents) listing.Iterator[compute.ClusterEvent] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[compute.ClusterEvent]
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetEvents) listing.Iterator[compute.ClusterEvent]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[compute.ClusterEvent])
		}
	}

	return r0
}

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

// Events is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.GetEvents
func (_e *MockClustersInterface_Expecter) Events(ctx interface{}, request interface{}) *MockClustersInterface_Events_Call {
	return &MockClustersInterface_Events_Call{Call: _e.mock.On("Events", ctx, request)}
}

func (_c *MockClustersInterface_Events_Call) Run(run func(ctx context.Context, request compute.GetEvents)) *MockClustersInterface_Events_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.GetEvents))
	})
	return _c
}

func (_c *MockClustersInterface_Events_Call) Return(_a0 listing.Iterator[compute.ClusterEvent]) *MockClustersInterface_Events_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_Events_Call) RunAndReturn(run func(context.Context, compute.GetEvents) listing.Iterator[compute.ClusterEvent]) *MockClustersInterface_Events_Call {
	_c.Call.Return(run)
	return _c
}

// EventsAll provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) EventsAll(ctx context.Context, request compute.GetEvents) ([]compute.ClusterEvent, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []compute.ClusterEvent
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetEvents) ([]compute.ClusterEvent, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetEvents) []compute.ClusterEvent); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]compute.ClusterEvent)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.GetEvents) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// EventsAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.GetEvents
func (_e *MockClustersInterface_Expecter) EventsAll(ctx interface{}, request interface{}) *MockClustersInterface_EventsAll_Call {
	return &MockClustersInterface_EventsAll_Call{Call: _e.mock.On("EventsAll", ctx, request)}
}

func (_c *MockClustersInterface_EventsAll_Call) Run(run func(ctx context.Context, request compute.GetEvents)) *MockClustersInterface_EventsAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.GetEvents))
	})
	return _c
}

func (_c *MockClustersInterface_EventsAll_Call) Return(_a0 []compute.ClusterEvent, _a1 error) *MockClustersInterface_EventsAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_EventsAll_Call) RunAndReturn(run func(context.Context, compute.GetEvents) ([]compute.ClusterEvent, error)) *MockClustersInterface_EventsAll_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) Get(ctx context.Context, request compute.GetClusterRequest) (*compute.ClusterDetails, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetClusterRequest) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetClusterRequest) *compute.ClusterDetails); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.GetClusterRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.GetClusterRequest
func (_e *MockClustersInterface_Expecter) Get(ctx interface{}, request interface{}) *MockClustersInterface_Get_Call {
	return &MockClustersInterface_Get_Call{Call: _e.mock.On("Get", ctx, request)}
}

func (_c *MockClustersInterface_Get_Call) Run(run func(ctx context.Context, request compute.GetClusterRequest)) *MockClustersInterface_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.GetClusterRequest))
	})
	return _c
}

func (_c *MockClustersInterface_Get_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_Get_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Get_Call) RunAndReturn(run func(context.Context, compute.GetClusterRequest) (*compute.ClusterDetails, error)) *MockClustersInterface_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) GetByClusterId(ctx context.Context, clusterId string) (*compute.ClusterDetails, error) {
	ret := _m.Called(ctx, clusterId)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, clusterId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *compute.ClusterDetails); ok {
		r0 = rf(ctx, clusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, clusterId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) GetByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_GetByClusterId_Call {
	return &MockClustersInterface_GetByClusterId_Call{Call: _e.mock.On("GetByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_GetByClusterId_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_GetByClusterId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_GetByClusterId_Call) RunAndReturn(run func(context.Context, string) (*compute.ClusterDetails, error)) *MockClustersInterface_GetByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// GetByClusterName provides a mock function with given fields: ctx, name
func (_m *MockClustersInterface) GetByClusterName(ctx context.Context, name string) (*compute.ClusterDetails, error) {
	ret := _m.Called(ctx, name)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *compute.ClusterDetails); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockClustersInterface_GetByClusterName_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_GetByClusterName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_GetByClusterName_Call) RunAndReturn(run func(context.Context, string) (*compute.ClusterDetails, error)) *MockClustersInterface_GetByClusterName_Call {
	_c.Call.Return(run)
	return _c
}

// GetOrCreateRunningCluster provides a mock function with given fields: ctx, name, custom
func (_m *MockClustersInterface) GetOrCreateRunningCluster(ctx context.Context, name string, custom ...compute.CreateCluster) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(custom))
	for _i := range custom {
		_va[_i] = custom[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, name)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...compute.CreateCluster) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, name, custom...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...compute.CreateCluster) *compute.ClusterDetails); ok {
		r0 = rf(ctx, name, custom...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...compute.CreateCluster) error); ok {
		r1 = rf(ctx, name, custom...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetOrCreateRunningCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - custom ...compute.CreateCluster
func (_e *MockClustersInterface_Expecter) GetOrCreateRunningCluster(ctx interface{}, name interface{}, custom ...interface{}) *MockClustersInterface_GetOrCreateRunningCluster_Call {
	return &MockClustersInterface_GetOrCreateRunningCluster_Call{Call: _e.mock.On("GetOrCreateRunningCluster",
		append([]interface{}{ctx, name}, custom...)...)}
}

func (_c *MockClustersInterface_GetOrCreateRunningCluster_Call) Run(run func(ctx context.Context, name string, custom ...compute.CreateCluster)) *MockClustersInterface_GetOrCreateRunningCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]compute.CreateCluster, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(compute.CreateCluster)
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_GetOrCreateRunningCluster_Call) Return(c *compute.ClusterDetails, err error) *MockClustersInterface_GetOrCreateRunningCluster_Call {
	_c.Call.Return(c, err)
	return _c
}

func (_c *MockClustersInterface_GetOrCreateRunningCluster_Call) RunAndReturn(run func(context.Context, string, ...compute.CreateCluster) (*compute.ClusterDetails, error)) *MockClustersInterface_GetOrCreateRunningCluster_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionLevels provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) GetPermissionLevels(ctx context.Context, request compute.GetClusterPermissionLevelsRequest) (*compute.GetClusterPermissionLevelsResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *compute.GetClusterPermissionLevelsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetClusterPermissionLevelsRequest) (*compute.GetClusterPermissionLevelsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetClusterPermissionLevelsRequest) *compute.GetClusterPermissionLevelsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.GetClusterPermissionLevelsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.GetClusterPermissionLevelsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPermissionLevels is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.GetClusterPermissionLevelsRequest
func (_e *MockClustersInterface_Expecter) GetPermissionLevels(ctx interface{}, request interface{}) *MockClustersInterface_GetPermissionLevels_Call {
	return &MockClustersInterface_GetPermissionLevels_Call{Call: _e.mock.On("GetPermissionLevels", ctx, request)}
}

func (_c *MockClustersInterface_GetPermissionLevels_Call) Run(run func(ctx context.Context, request compute.GetClusterPermissionLevelsRequest)) *MockClustersInterface_GetPermissionLevels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.GetClusterPermissionLevelsRequest))
	})
	return _c
}

func (_c *MockClustersInterface_GetPermissionLevels_Call) Return(_a0 *compute.GetClusterPermissionLevelsResponse, _a1 error) *MockClustersInterface_GetPermissionLevels_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_GetPermissionLevels_Call) RunAndReturn(run func(context.Context, compute.GetClusterPermissionLevelsRequest) (*compute.GetClusterPermissionLevelsResponse, error)) *MockClustersInterface_GetPermissionLevels_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionLevelsByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) GetPermissionLevelsByClusterId(ctx context.Context, clusterId string) (*compute.GetClusterPermissionLevelsResponse, error) {
	ret := _m.Called(ctx, clusterId)

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

	var r0 *compute.GetClusterPermissionLevelsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*compute.GetClusterPermissionLevelsResponse, error)); ok {
		return rf(ctx, clusterId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *compute.GetClusterPermissionLevelsResponse); ok {
		r0 = rf(ctx, clusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.GetClusterPermissionLevelsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, clusterId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPermissionLevelsByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) GetPermissionLevelsByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_GetPermissionLevelsByClusterId_Call {
	return &MockClustersInterface_GetPermissionLevelsByClusterId_Call{Call: _e.mock.On("GetPermissionLevelsByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_GetPermissionLevelsByClusterId_Call) Return(_a0 *compute.GetClusterPermissionLevelsResponse, _a1 error) *MockClustersInterface_GetPermissionLevelsByClusterId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_GetPermissionLevelsByClusterId_Call) RunAndReturn(run func(context.Context, string) (*compute.GetClusterPermissionLevelsResponse, error)) *MockClustersInterface_GetPermissionLevelsByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissions provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) GetPermissions(ctx context.Context, request compute.GetClusterPermissionsRequest) (*compute.ClusterPermissions, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *compute.ClusterPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetClusterPermissionsRequest) (*compute.ClusterPermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.GetClusterPermissionsRequest) *compute.ClusterPermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.GetClusterPermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.GetClusterPermissionsRequest
func (_e *MockClustersInterface_Expecter) GetPermissions(ctx interface{}, request interface{}) *MockClustersInterface_GetPermissions_Call {
	return &MockClustersInterface_GetPermissions_Call{Call: _e.mock.On("GetPermissions", ctx, request)}
}

func (_c *MockClustersInterface_GetPermissions_Call) Run(run func(ctx context.Context, request compute.GetClusterPermissionsRequest)) *MockClustersInterface_GetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.GetClusterPermissionsRequest))
	})
	return _c
}

func (_c *MockClustersInterface_GetPermissions_Call) Return(_a0 *compute.ClusterPermissions, _a1 error) *MockClustersInterface_GetPermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_GetPermissions_Call) RunAndReturn(run func(context.Context, compute.GetClusterPermissionsRequest) (*compute.ClusterPermissions, error)) *MockClustersInterface_GetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionsByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) GetPermissionsByClusterId(ctx context.Context, clusterId string) (*compute.ClusterPermissions, error) {
	ret := _m.Called(ctx, clusterId)

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

	var r0 *compute.ClusterPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*compute.ClusterPermissions, error)); ok {
		return rf(ctx, clusterId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *compute.ClusterPermissions); ok {
		r0 = rf(ctx, clusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, clusterId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPermissionsByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) GetPermissionsByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_GetPermissionsByClusterId_Call {
	return &MockClustersInterface_GetPermissionsByClusterId_Call{Call: _e.mock.On("GetPermissionsByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_GetPermissionsByClusterId_Call) Return(_a0 *compute.ClusterPermissions, _a1 error) *MockClustersInterface_GetPermissionsByClusterId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_GetPermissionsByClusterId_Call) RunAndReturn(run func(context.Context, string) (*compute.ClusterPermissions, error)) *MockClustersInterface_GetPermissionsByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// Impl provides a mock function with given fields:
func (_m *MockClustersInterface) Impl() compute.ClustersService {
	ret := _m.Called()

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

	var r0 compute.ClustersService
	if rf, ok := ret.Get(0).(func() compute.ClustersService); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(compute.ClustersService)
		}
	}

	return r0
}

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

// Impl is a helper method to define mock.On call
func (_e *MockClustersInterface_Expecter) Impl() *MockClustersInterface_Impl_Call {
	return &MockClustersInterface_Impl_Call{Call: _e.mock.On("Impl")}
}

func (_c *MockClustersInterface_Impl_Call) Run(run func()) *MockClustersInterface_Impl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClustersInterface_Impl_Call) Return(_a0 compute.ClustersService) *MockClustersInterface_Impl_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_Impl_Call) RunAndReturn(run func() compute.ClustersService) *MockClustersInterface_Impl_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) List(ctx context.Context, request compute.ListClustersRequest) listing.Iterator[compute.ClusterDetails] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[compute.ClusterDetails]
	if rf, ok := ret.Get(0).(func(context.Context, compute.ListClustersRequest) listing.Iterator[compute.ClusterDetails]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[compute.ClusterDetails])
		}
	}

	return r0
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.ListClustersRequest
func (_e *MockClustersInterface_Expecter) List(ctx interface{}, request interface{}) *MockClustersInterface_List_Call {
	return &MockClustersInterface_List_Call{Call: _e.mock.On("List", ctx, request)}
}

func (_c *MockClustersInterface_List_Call) Run(run func(ctx context.Context, request compute.ListClustersRequest)) *MockClustersInterface_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ListClustersRequest))
	})
	return _c
}

func (_c *MockClustersInterface_List_Call) Return(_a0 listing.Iterator[compute.ClusterDetails]) *MockClustersInterface_List_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_List_Call) RunAndReturn(run func(context.Context, compute.ListClustersRequest) listing.Iterator[compute.ClusterDetails]) *MockClustersInterface_List_Call {
	_c.Call.Return(run)
	return _c
}

// ListAll provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) ListAll(ctx context.Context, request compute.ListClustersRequest) ([]compute.ClusterDetails, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ListClustersRequest) ([]compute.ClusterDetails, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.ListClustersRequest) []compute.ClusterDetails); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.ListClustersRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.ListClustersRequest
func (_e *MockClustersInterface_Expecter) ListAll(ctx interface{}, request interface{}) *MockClustersInterface_ListAll_Call {
	return &MockClustersInterface_ListAll_Call{Call: _e.mock.On("ListAll", ctx, request)}
}

func (_c *MockClustersInterface_ListAll_Call) Run(run func(ctx context.Context, request compute.ListClustersRequest)) *MockClustersInterface_ListAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ListClustersRequest))
	})
	return _c
}

func (_c *MockClustersInterface_ListAll_Call) Return(_a0 []compute.ClusterDetails, _a1 error) *MockClustersInterface_ListAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_ListAll_Call) RunAndReturn(run func(context.Context, compute.ListClustersRequest) ([]compute.ClusterDetails, error)) *MockClustersInterface_ListAll_Call {
	_c.Call.Return(run)
	return _c
}

// ListByCanUseClient provides a mock function with given fields: ctx, canUseClient
func (_m *MockClustersInterface) ListByCanUseClient(ctx context.Context, canUseClient string) (*compute.ListClustersResponse, error) {
	ret := _m.Called(ctx, canUseClient)

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

	var r0 *compute.ListClustersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*compute.ListClustersResponse, error)); ok {
		return rf(ctx, canUseClient)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *compute.ListClustersResponse); ok {
		r0 = rf(ctx, canUseClient)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ListClustersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, canUseClient)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListByCanUseClient is a helper method to define mock.On call
//   - ctx context.Context
//   - canUseClient string
func (_e *MockClustersInterface_Expecter) ListByCanUseClient(ctx interface{}, canUseClient interface{}) *MockClustersInterface_ListByCanUseClient_Call {
	return &MockClustersInterface_ListByCanUseClient_Call{Call: _e.mock.On("ListByCanUseClient", ctx, canUseClient)}
}

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

func (_c *MockClustersInterface_ListByCanUseClient_Call) Return(_a0 *compute.ListClustersResponse, _a1 error) *MockClustersInterface_ListByCanUseClient_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_ListByCanUseClient_Call) RunAndReturn(run func(context.Context, string) (*compute.ListClustersResponse, error)) *MockClustersInterface_ListByCanUseClient_Call {
	_c.Call.Return(run)
	return _c
}

// ListNodeTypes provides a mock function with given fields: ctx
func (_m *MockClustersInterface) ListNodeTypes(ctx context.Context) (*compute.ListNodeTypesResponse, error) {
	ret := _m.Called(ctx)

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

	var r0 *compute.ListNodeTypesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*compute.ListNodeTypesResponse, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *compute.ListNodeTypesResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ListNodeTypesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockClustersInterface_ListNodeTypes_Call) Return(_a0 *compute.ListNodeTypesResponse, _a1 error) *MockClustersInterface_ListNodeTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_ListNodeTypes_Call) RunAndReturn(run func(context.Context) (*compute.ListNodeTypesResponse, error)) *MockClustersInterface_ListNodeTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListZones provides a mock function with given fields: ctx
func (_m *MockClustersInterface) ListZones(ctx context.Context) (*compute.ListAvailableZonesResponse, error) {
	ret := _m.Called(ctx)

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

	var r0 *compute.ListAvailableZonesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*compute.ListAvailableZonesResponse, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *compute.ListAvailableZonesResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ListAvailableZonesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockClustersInterface_ListZones_Call) Return(_a0 *compute.ListAvailableZonesResponse, _a1 error) *MockClustersInterface_ListZones_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_ListZones_Call) RunAndReturn(run func(context.Context) (*compute.ListAvailableZonesResponse, error)) *MockClustersInterface_ListZones_Call {
	_c.Call.Return(run)
	return _c
}

// PermanentDelete provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) PermanentDelete(ctx context.Context, request compute.PermanentDeleteCluster) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.PermanentDeleteCluster) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PermanentDelete is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.PermanentDeleteCluster
func (_e *MockClustersInterface_Expecter) PermanentDelete(ctx interface{}, request interface{}) *MockClustersInterface_PermanentDelete_Call {
	return &MockClustersInterface_PermanentDelete_Call{Call: _e.mock.On("PermanentDelete", ctx, request)}
}

func (_c *MockClustersInterface_PermanentDelete_Call) Run(run func(ctx context.Context, request compute.PermanentDeleteCluster)) *MockClustersInterface_PermanentDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.PermanentDeleteCluster))
	})
	return _c
}

func (_c *MockClustersInterface_PermanentDelete_Call) Return(_a0 error) *MockClustersInterface_PermanentDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_PermanentDelete_Call) RunAndReturn(run func(context.Context, compute.PermanentDeleteCluster) error) *MockClustersInterface_PermanentDelete_Call {
	_c.Call.Return(run)
	return _c
}

// PermanentDeleteByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) PermanentDeleteByClusterId(ctx context.Context, clusterId string) error {
	ret := _m.Called(ctx, clusterId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, clusterId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PermanentDeleteByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) PermanentDeleteByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_PermanentDeleteByClusterId_Call {
	return &MockClustersInterface_PermanentDeleteByClusterId_Call{Call: _e.mock.On("PermanentDeleteByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_PermanentDeleteByClusterId_Call) Return(_a0 error) *MockClustersInterface_PermanentDeleteByClusterId_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_PermanentDeleteByClusterId_Call) RunAndReturn(run func(context.Context, string) error) *MockClustersInterface_PermanentDeleteByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// Pin provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) Pin(ctx context.Context, request compute.PinCluster) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.PinCluster) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Pin is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.PinCluster
func (_e *MockClustersInterface_Expecter) Pin(ctx interface{}, request interface{}) *MockClustersInterface_Pin_Call {
	return &MockClustersInterface_Pin_Call{Call: _e.mock.On("Pin", ctx, request)}
}

func (_c *MockClustersInterface_Pin_Call) Run(run func(ctx context.Context, request compute.PinCluster)) *MockClustersInterface_Pin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.PinCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Pin_Call) Return(_a0 error) *MockClustersInterface_Pin_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_Pin_Call) RunAndReturn(run func(context.Context, compute.PinCluster) error) *MockClustersInterface_Pin_Call {
	_c.Call.Return(run)
	return _c
}

// PinByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) PinByClusterId(ctx context.Context, clusterId string) error {
	ret := _m.Called(ctx, clusterId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, clusterId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PinByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) PinByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_PinByClusterId_Call {
	return &MockClustersInterface_PinByClusterId_Call{Call: _e.mock.On("PinByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_PinByClusterId_Call) Return(_a0 error) *MockClustersInterface_PinByClusterId_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_PinByClusterId_Call) RunAndReturn(run func(context.Context, string) error) *MockClustersInterface_PinByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// Resize provides a mock function with given fields: ctx, resizeCluster
func (_m *MockClustersInterface) Resize(ctx context.Context, resizeCluster compute.ResizeCluster) (*compute.WaitGetClusterRunning[struct{}], error) {
	ret := _m.Called(ctx, resizeCluster)

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

	var r0 *compute.WaitGetClusterRunning[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ResizeCluster) (*compute.WaitGetClusterRunning[struct{}], error)); ok {
		return rf(ctx, resizeCluster)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.ResizeCluster) *compute.WaitGetClusterRunning[struct{}]); ok {
		r0 = rf(ctx, resizeCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.WaitGetClusterRunning[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.ResizeCluster) error); ok {
		r1 = rf(ctx, resizeCluster)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Resize is a helper method to define mock.On call
//   - ctx context.Context
//   - resizeCluster compute.ResizeCluster
func (_e *MockClustersInterface_Expecter) Resize(ctx interface{}, resizeCluster interface{}) *MockClustersInterface_Resize_Call {
	return &MockClustersInterface_Resize_Call{Call: _e.mock.On("Resize", ctx, resizeCluster)}
}

func (_c *MockClustersInterface_Resize_Call) Run(run func(ctx context.Context, resizeCluster compute.ResizeCluster)) *MockClustersInterface_Resize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ResizeCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Resize_Call) Return(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 error) *MockClustersInterface_Resize_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Resize_Call) RunAndReturn(run func(context.Context, compute.ResizeCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Resize_Call {
	_c.Call.Return(run)
	return _c
}

// ResizeAndWait provides a mock function with given fields: ctx, resizeCluster, options
func (_m *MockClustersInterface) ResizeAndWait(ctx context.Context, resizeCluster compute.ResizeCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, resizeCluster)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ResizeCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, resizeCluster, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.ResizeCluster, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, resizeCluster, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.ResizeCluster, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, resizeCluster, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ResizeAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - resizeCluster compute.ResizeCluster
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) ResizeAndWait(ctx interface{}, resizeCluster interface{}, options ...interface{}) *MockClustersInterface_ResizeAndWait_Call {
	return &MockClustersInterface_ResizeAndWait_Call{Call: _e.mock.On("ResizeAndWait",
		append([]interface{}{ctx, resizeCluster}, options...)...)}
}

func (_c *MockClustersInterface_ResizeAndWait_Call) Run(run func(ctx context.Context, resizeCluster compute.ResizeCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_ResizeAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(compute.ResizeCluster), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_ResizeAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_ResizeAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_ResizeAndWait_Call) RunAndReturn(run func(context.Context, compute.ResizeCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_ResizeAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// Restart provides a mock function with given fields: ctx, restartCluster
func (_m *MockClustersInterface) Restart(ctx context.Context, restartCluster compute.RestartCluster) (*compute.WaitGetClusterRunning[struct{}], error) {
	ret := _m.Called(ctx, restartCluster)

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

	var r0 *compute.WaitGetClusterRunning[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.RestartCluster) (*compute.WaitGetClusterRunning[struct{}], error)); ok {
		return rf(ctx, restartCluster)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.RestartCluster) *compute.WaitGetClusterRunning[struct{}]); ok {
		r0 = rf(ctx, restartCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.WaitGetClusterRunning[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.RestartCluster) error); ok {
		r1 = rf(ctx, restartCluster)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Restart is a helper method to define mock.On call
//   - ctx context.Context
//   - restartCluster compute.RestartCluster
func (_e *MockClustersInterface_Expecter) Restart(ctx interface{}, restartCluster interface{}) *MockClustersInterface_Restart_Call {
	return &MockClustersInterface_Restart_Call{Call: _e.mock.On("Restart", ctx, restartCluster)}
}

func (_c *MockClustersInterface_Restart_Call) Run(run func(ctx context.Context, restartCluster compute.RestartCluster)) *MockClustersInterface_Restart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.RestartCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Restart_Call) Return(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 error) *MockClustersInterface_Restart_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Restart_Call) RunAndReturn(run func(context.Context, compute.RestartCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Restart_Call {
	_c.Call.Return(run)
	return _c
}

// RestartAndWait provides a mock function with given fields: ctx, restartCluster, options
func (_m *MockClustersInterface) RestartAndWait(ctx context.Context, restartCluster compute.RestartCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, restartCluster)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.RestartCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, restartCluster, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.RestartCluster, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, restartCluster, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.RestartCluster, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, restartCluster, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RestartAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - restartCluster compute.RestartCluster
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) RestartAndWait(ctx interface{}, restartCluster interface{}, options ...interface{}) *MockClustersInterface_RestartAndWait_Call {
	return &MockClustersInterface_RestartAndWait_Call{Call: _e.mock.On("RestartAndWait",
		append([]interface{}{ctx, restartCluster}, options...)...)}
}

func (_c *MockClustersInterface_RestartAndWait_Call) Run(run func(ctx context.Context, restartCluster compute.RestartCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_RestartAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(compute.RestartCluster), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_RestartAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_RestartAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_RestartAndWait_Call) RunAndReturn(run func(context.Context, compute.RestartCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_RestartAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// SelectNodeType provides a mock function with given fields: ctx, r
func (_m *MockClustersInterface) SelectNodeType(ctx context.Context, r compute.NodeTypeRequest) (string, error) {
	ret := _m.Called(ctx, r)

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

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.NodeTypeRequest) (string, error)); ok {
		return rf(ctx, r)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.NodeTypeRequest) string); ok {
		r0 = rf(ctx, r)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.NodeTypeRequest) error); ok {
		r1 = rf(ctx, r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectNodeType is a helper method to define mock.On call
//   - ctx context.Context
//   - r compute.NodeTypeRequest
func (_e *MockClustersInterface_Expecter) SelectNodeType(ctx interface{}, r interface{}) *MockClustersInterface_SelectNodeType_Call {
	return &MockClustersInterface_SelectNodeType_Call{Call: _e.mock.On("SelectNodeType", ctx, r)}
}

func (_c *MockClustersInterface_SelectNodeType_Call) Run(run func(ctx context.Context, r compute.NodeTypeRequest)) *MockClustersInterface_SelectNodeType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.NodeTypeRequest))
	})
	return _c
}

func (_c *MockClustersInterface_SelectNodeType_Call) Return(_a0 string, _a1 error) *MockClustersInterface_SelectNodeType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_SelectNodeType_Call) RunAndReturn(run func(context.Context, compute.NodeTypeRequest) (string, error)) *MockClustersInterface_SelectNodeType_Call {
	_c.Call.Return(run)
	return _c
}

// SelectSparkVersion provides a mock function with given fields: ctx, r
func (_m *MockClustersInterface) SelectSparkVersion(ctx context.Context, r compute.SparkVersionRequest) (string, error) {
	ret := _m.Called(ctx, r)

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

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.SparkVersionRequest) (string, error)); ok {
		return rf(ctx, r)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.SparkVersionRequest) string); ok {
		r0 = rf(ctx, r)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.SparkVersionRequest) error); ok {
		r1 = rf(ctx, r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectSparkVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - r compute.SparkVersionRequest
func (_e *MockClustersInterface_Expecter) SelectSparkVersion(ctx interface{}, r interface{}) *MockClustersInterface_SelectSparkVersion_Call {
	return &MockClustersInterface_SelectSparkVersion_Call{Call: _e.mock.On("SelectSparkVersion", ctx, r)}
}

func (_c *MockClustersInterface_SelectSparkVersion_Call) Run(run func(ctx context.Context, r compute.SparkVersionRequest)) *MockClustersInterface_SelectSparkVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.SparkVersionRequest))
	})
	return _c
}

func (_c *MockClustersInterface_SelectSparkVersion_Call) Return(_a0 string, _a1 error) *MockClustersInterface_SelectSparkVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_SelectSparkVersion_Call) RunAndReturn(run func(context.Context, compute.SparkVersionRequest) (string, error)) *MockClustersInterface_SelectSparkVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetPermissions provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) SetPermissions(ctx context.Context, request compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *compute.ClusterPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.ClusterPermissionsRequest) *compute.ClusterPermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.ClusterPermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.ClusterPermissionsRequest
func (_e *MockClustersInterface_Expecter) SetPermissions(ctx interface{}, request interface{}) *MockClustersInterface_SetPermissions_Call {
	return &MockClustersInterface_SetPermissions_Call{Call: _e.mock.On("SetPermissions", ctx, request)}
}

func (_c *MockClustersInterface_SetPermissions_Call) Run(run func(ctx context.Context, request compute.ClusterPermissionsRequest)) *MockClustersInterface_SetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ClusterPermissionsRequest))
	})
	return _c
}

func (_c *MockClustersInterface_SetPermissions_Call) Return(_a0 *compute.ClusterPermissions, _a1 error) *MockClustersInterface_SetPermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_SetPermissions_Call) RunAndReturn(run func(context.Context, compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)) *MockClustersInterface_SetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// SparkVersions provides a mock function with given fields: ctx
func (_m *MockClustersInterface) SparkVersions(ctx context.Context) (*compute.GetSparkVersionsResponse, error) {
	ret := _m.Called(ctx)

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

	var r0 *compute.GetSparkVersionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*compute.GetSparkVersionsResponse, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *compute.GetSparkVersionsResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.GetSparkVersionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockClustersInterface_SparkVersions_Call) Return(_a0 *compute.GetSparkVersionsResponse, _a1 error) *MockClustersInterface_SparkVersions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_SparkVersions_Call) RunAndReturn(run func(context.Context) (*compute.GetSparkVersionsResponse, error)) *MockClustersInterface_SparkVersions_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function with given fields: ctx, startCluster
func (_m *MockClustersInterface) Start(ctx context.Context, startCluster compute.StartCluster) (*compute.WaitGetClusterRunning[struct{}], error) {
	ret := _m.Called(ctx, startCluster)

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

	var r0 *compute.WaitGetClusterRunning[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.StartCluster) (*compute.WaitGetClusterRunning[struct{}], error)); ok {
		return rf(ctx, startCluster)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.StartCluster) *compute.WaitGetClusterRunning[struct{}]); ok {
		r0 = rf(ctx, startCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.WaitGetClusterRunning[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.StartCluster) error); ok {
		r1 = rf(ctx, startCluster)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Start is a helper method to define mock.On call
//   - ctx context.Context
//   - startCluster compute.StartCluster
func (_e *MockClustersInterface_Expecter) Start(ctx interface{}, startCluster interface{}) *MockClustersInterface_Start_Call {
	return &MockClustersInterface_Start_Call{Call: _e.mock.On("Start", ctx, startCluster)}
}

func (_c *MockClustersInterface_Start_Call) Run(run func(ctx context.Context, startCluster compute.StartCluster)) *MockClustersInterface_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.StartCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Start_Call) Return(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 error) *MockClustersInterface_Start_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_Start_Call) RunAndReturn(run func(context.Context, compute.StartCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Start_Call {
	_c.Call.Return(run)
	return _c
}

// StartAndWait provides a mock function with given fields: ctx, startCluster, options
func (_m *MockClustersInterface) StartAndWait(ctx context.Context, startCluster compute.StartCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, startCluster)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.StartCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, startCluster, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.StartCluster, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, startCluster, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.StartCluster, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, startCluster, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StartAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - startCluster compute.StartCluster
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) StartAndWait(ctx interface{}, startCluster interface{}, options ...interface{}) *MockClustersInterface_StartAndWait_Call {
	return &MockClustersInterface_StartAndWait_Call{Call: _e.mock.On("StartAndWait",
		append([]interface{}{ctx, startCluster}, options...)...)}
}

func (_c *MockClustersInterface_StartAndWait_Call) Run(run func(ctx context.Context, startCluster compute.StartCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_StartAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(compute.StartCluster), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_StartAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_StartAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_StartAndWait_Call) RunAndReturn(run func(context.Context, compute.StartCluster, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_StartAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// StartByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) StartByClusterId(ctx context.Context, clusterId string) error {
	ret := _m.Called(ctx, clusterId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, clusterId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// StartByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) StartByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_StartByClusterId_Call {
	return &MockClustersInterface_StartByClusterId_Call{Call: _e.mock.On("StartByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_StartByClusterId_Call) Return(_a0 error) *MockClustersInterface_StartByClusterId_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_StartByClusterId_Call) RunAndReturn(run func(context.Context, string) error) *MockClustersInterface_StartByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// StartByClusterIdAndWait provides a mock function with given fields: ctx, clusterId, options
func (_m *MockClustersInterface) StartByClusterIdAndWait(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, clusterId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, clusterId, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...retries.Option[compute.ClusterDetails]) *compute.ClusterDetails); ok {
		r0 = rf(ctx, clusterId, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...retries.Option[compute.ClusterDetails]) error); ok {
		r1 = rf(ctx, clusterId, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StartByClusterIdAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - options ...retries.Option[compute.ClusterDetails]
func (_e *MockClustersInterface_Expecter) StartByClusterIdAndWait(ctx interface{}, clusterId interface{}, options ...interface{}) *MockClustersInterface_StartByClusterIdAndWait_Call {
	return &MockClustersInterface_StartByClusterIdAndWait_Call{Call: _e.mock.On("StartByClusterIdAndWait",
		append([]interface{}{ctx, clusterId}, options...)...)}
}

func (_c *MockClustersInterface_StartByClusterIdAndWait_Call) Run(run func(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_StartByClusterIdAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[compute.ClusterDetails], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[compute.ClusterDetails])
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClustersInterface_StartByClusterIdAndWait_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_StartByClusterIdAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_StartByClusterIdAndWait_Call) RunAndReturn(run func(context.Context, string, ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_StartByClusterIdAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// Unpin provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) Unpin(ctx context.Context, request compute.UnpinCluster) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.UnpinCluster) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Unpin is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.UnpinCluster
func (_e *MockClustersInterface_Expecter) Unpin(ctx interface{}, request interface{}) *MockClustersInterface_Unpin_Call {
	return &MockClustersInterface_Unpin_Call{Call: _e.mock.On("Unpin", ctx, request)}
}

func (_c *MockClustersInterface_Unpin_Call) Run(run func(ctx context.Context, request compute.UnpinCluster)) *MockClustersInterface_Unpin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.UnpinCluster))
	})
	return _c
}

func (_c *MockClustersInterface_Unpin_Call) Return(_a0 error) *MockClustersInterface_Unpin_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_Unpin_Call) RunAndReturn(run func(context.Context, compute.UnpinCluster) error) *MockClustersInterface_Unpin_Call {
	_c.Call.Return(run)
	return _c
}

// UnpinByClusterId provides a mock function with given fields: ctx, clusterId
func (_m *MockClustersInterface) UnpinByClusterId(ctx context.Context, clusterId string) error {
	ret := _m.Called(ctx, clusterId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, clusterId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UnpinByClusterId is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
func (_e *MockClustersInterface_Expecter) UnpinByClusterId(ctx interface{}, clusterId interface{}) *MockClustersInterface_UnpinByClusterId_Call {
	return &MockClustersInterface_UnpinByClusterId_Call{Call: _e.mock.On("UnpinByClusterId", ctx, clusterId)}
}

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

func (_c *MockClustersInterface_UnpinByClusterId_Call) Return(_a0 error) *MockClustersInterface_UnpinByClusterId_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_UnpinByClusterId_Call) RunAndReturn(run func(context.Context, string) error) *MockClustersInterface_UnpinByClusterId_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePermissions provides a mock function with given fields: ctx, request
func (_m *MockClustersInterface) UpdatePermissions(ctx context.Context, request compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *compute.ClusterPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, compute.ClusterPermissionsRequest) *compute.ClusterPermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, compute.ClusterPermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdatePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request compute.ClusterPermissionsRequest
func (_e *MockClustersInterface_Expecter) UpdatePermissions(ctx interface{}, request interface{}) *MockClustersInterface_UpdatePermissions_Call {
	return &MockClustersInterface_UpdatePermissions_Call{Call: _e.mock.On("UpdatePermissions", ctx, request)}
}

func (_c *MockClustersInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request compute.ClusterPermissionsRequest)) *MockClustersInterface_UpdatePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(compute.ClusterPermissionsRequest))
	})
	return _c
}

func (_c *MockClustersInterface_UpdatePermissions_Call) Return(_a0 *compute.ClusterPermissions, _a1 error) *MockClustersInterface_UpdatePermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_UpdatePermissions_Call) RunAndReturn(run func(context.Context, compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)) *MockClustersInterface_UpdatePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// WaitGetClusterRunning provides a mock function with given fields: ctx, clusterId, timeout, callback
func (_m *MockClustersInterface) WaitGetClusterRunning(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails)) (*compute.ClusterDetails, error) {
	ret := _m.Called(ctx, clusterId, timeout, callback)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, clusterId, timeout, callback)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) *compute.ClusterDetails); ok {
		r0 = rf(ctx, clusterId, timeout, callback)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) error); ok {
		r1 = rf(ctx, clusterId, timeout, callback)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WaitGetClusterRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - timeout time.Duration
//   - callback func(*compute.ClusterDetails)
func (_e *MockClustersInterface_Expecter) WaitGetClusterRunning(ctx interface{}, clusterId interface{}, timeout interface{}, callback interface{}) *MockClustersInterface_WaitGetClusterRunning_Call {
	return &MockClustersInterface_WaitGetClusterRunning_Call{Call: _e.mock.On("WaitGetClusterRunning", ctx, clusterId, timeout, callback)}
}

func (_c *MockClustersInterface_WaitGetClusterRunning_Call) Run(run func(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails))) *MockClustersInterface_WaitGetClusterRunning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(func(*compute.ClusterDetails)))
	})
	return _c
}

func (_c *MockClustersInterface_WaitGetClusterRunning_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_WaitGetClusterRunning_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_WaitGetClusterRunning_Call) RunAndReturn(run func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)) *MockClustersInterface_WaitGetClusterRunning_Call {
	_c.Call.Return(run)
	return _c
}

// WaitGetClusterTerminated provides a mock function with given fields: ctx, clusterId, timeout, callback
func (_m *MockClustersInterface) WaitGetClusterTerminated(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails)) (*compute.ClusterDetails, error) {
	ret := _m.Called(ctx, clusterId, timeout, callback)

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

	var r0 *compute.ClusterDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)); ok {
		return rf(ctx, clusterId, timeout, callback)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) *compute.ClusterDetails); ok {
		r0 = rf(ctx, clusterId, timeout, callback)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*compute.ClusterDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) error); ok {
		r1 = rf(ctx, clusterId, timeout, callback)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WaitGetClusterTerminated is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - timeout time.Duration
//   - callback func(*compute.ClusterDetails)
func (_e *MockClustersInterface_Expecter) WaitGetClusterTerminated(ctx interface{}, clusterId interface{}, timeout interface{}, callback interface{}) *MockClustersInterface_WaitGetClusterTerminated_Call {
	return &MockClustersInterface_WaitGetClusterTerminated_Call{Call: _e.mock.On("WaitGetClusterTerminated", ctx, clusterId, timeout, callback)}
}

func (_c *MockClustersInterface_WaitGetClusterTerminated_Call) Run(run func(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails))) *MockClustersInterface_WaitGetClusterTerminated_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(func(*compute.ClusterDetails)))
	})
	return _c
}

func (_c *MockClustersInterface_WaitGetClusterTerminated_Call) Return(_a0 *compute.ClusterDetails, _a1 error) *MockClustersInterface_WaitGetClusterTerminated_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClustersInterface_WaitGetClusterTerminated_Call) RunAndReturn(run func(context.Context, string, time.Duration, func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)) *MockClustersInterface_WaitGetClusterTerminated_Call {
	_c.Call.Return(run)
	return _c
}

// WithImpl provides a mock function with given fields: impl
func (_m *MockClustersInterface) WithImpl(impl compute.ClustersService) compute.ClustersInterface {
	ret := _m.Called(impl)

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

	var r0 compute.ClustersInterface
	if rf, ok := ret.Get(0).(func(compute.ClustersService) compute.ClustersInterface); ok {
		r0 = rf(impl)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(compute.ClustersInterface)
		}
	}

	return r0
}

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

// WithImpl is a helper method to define mock.On call
//   - impl compute.ClustersService
func (_e *MockClustersInterface_Expecter) WithImpl(impl interface{}) *MockClustersInterface_WithImpl_Call {
	return &MockClustersInterface_WithImpl_Call{Call: _e.mock.On("WithImpl", impl)}
}

func (_c *MockClustersInterface_WithImpl_Call) Run(run func(impl compute.ClustersService)) *MockClustersInterface_WithImpl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(compute.ClustersService))
	})
	return _c
}

func (_c *MockClustersInterface_WithImpl_Call) Return(_a0 compute.ClustersInterface) *MockClustersInterface_WithImpl_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClustersInterface_WithImpl_Call) RunAndReturn(run func(compute.ClustersService) compute.ClustersInterface) *MockClustersInterface_WithImpl_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}