// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	mock "github.com/stretchr/testify/mock"
	"github.com/tidbcloud/cluster-service-ng/api/cluster-service-ng/v1beta"
	"github.com/tidbcloud/cluster-service-ng/domain/entity"
	"github.com/tidbcloud/cluster-service-ng/domain/server"
	"github.com/tidbcloud/cluster-service-ng/domain/server/br"
	"github.com/tidbcloud/cluster-service-ng/pkg/storage/repo"
	"google.golang.org/protobuf/types/known/wrapperspb"
)

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

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

	return mock
}

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

type restoreResourceInput_Expecter struct {
	mock *mock.Mock
}

func (_m *restoreResourceInput) EXPECT() *restoreResourceInput_Expecter {
	return &restoreResourceInput_Expecter{mock: &_m.Mock}
}

// GetResourceCpu provides a mock function for the type restoreResourceInput
func (_mock *restoreResourceInput) GetResourceCpu() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetResourceCpu is a helper method to define mock.On call
func (_e *restoreResourceInput_Expecter) GetResourceCpu() *restoreResourceInput_GetResourceCpu_Call {
	return &restoreResourceInput_GetResourceCpu_Call{Call: _e.mock.On("GetResourceCpu")}
}

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

func (_c *restoreResourceInput_GetResourceCpu_Call) Return(s string) *restoreResourceInput_GetResourceCpu_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *restoreResourceInput_GetResourceCpu_Call) RunAndReturn(run func() string) *restoreResourceInput_GetResourceCpu_Call {
	_c.Call.Return(run)
	return _c
}

// GetResourceMemory provides a mock function for the type restoreResourceInput
func (_mock *restoreResourceInput) GetResourceMemory() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetResourceMemory is a helper method to define mock.On call
func (_e *restoreResourceInput_Expecter) GetResourceMemory() *restoreResourceInput_GetResourceMemory_Call {
	return &restoreResourceInput_GetResourceMemory_Call{Call: _e.mock.On("GetResourceMemory")}
}

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

func (_c *restoreResourceInput_GetResourceMemory_Call) Return(s string) *restoreResourceInput_GetResourceMemory_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *restoreResourceInput_GetResourceMemory_Call) RunAndReturn(run func() string) *restoreResourceInput_GetResourceMemory_Call {
	_c.Call.Return(run)
	return _c
}

// GetResourceStorage provides a mock function for the type restoreResourceInput
func (_mock *restoreResourceInput) GetResourceStorage() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetResourceStorage is a helper method to define mock.On call
func (_e *restoreResourceInput_Expecter) GetResourceStorage() *restoreResourceInput_GetResourceStorage_Call {
	return &restoreResourceInput_GetResourceStorage_Call{Call: _e.mock.On("GetResourceStorage")}
}

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

func (_c *restoreResourceInput_GetResourceStorage_Call) Return(s string) *restoreResourceInput_GetResourceStorage_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *restoreResourceInput_GetResourceStorage_Call) RunAndReturn(run func() string) *restoreResourceInput_GetResourceStorage_Call {
	_c.Call.Return(run)
	return _c
}

// GetTargetSharedPoolId provides a mock function for the type restoreResourceInput
func (_mock *restoreResourceInput) GetTargetSharedPoolId() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetTargetSharedPoolId is a helper method to define mock.On call
func (_e *restoreResourceInput_Expecter) GetTargetSharedPoolId() *restoreResourceInput_GetTargetSharedPoolId_Call {
	return &restoreResourceInput_GetTargetSharedPoolId_Call{Call: _e.mock.On("GetTargetSharedPoolId")}
}

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

func (_c *restoreResourceInput_GetTargetSharedPoolId_Call) Return(s string) *restoreResourceInput_GetTargetSharedPoolId_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *restoreResourceInput_GetTargetSharedPoolId_Call) RunAndReturn(run func() string) *restoreResourceInput_GetTargetSharedPoolId_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type batchScaleSharedPoolService_Expecter struct {
	mock *mock.Mock
}

func (_m *batchScaleSharedPoolService) EXPECT() *batchScaleSharedPoolService_Expecter {
	return &batchScaleSharedPoolService_Expecter{mock: &_m.Mock}
}

// ScaleSharedPoolBatch provides a mock function for the type batchScaleSharedPoolService
func (_mock *batchScaleSharedPoolService) ScaleSharedPoolBatch(ctx context.Context, sharedPoolId string, scaleComponents []*entity.Component, force bool) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, scaleComponents, force)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.Component, bool) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, scaleComponents, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.Component, bool) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, scaleComponents, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, []*entity.Component, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, scaleComponents, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ScaleSharedPoolBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - scaleComponents []*entity.Component
//   - force bool
func (_e *batchScaleSharedPoolService_Expecter) ScaleSharedPoolBatch(ctx interface{}, sharedPoolId interface{}, scaleComponents interface{}, force interface{}) *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call {
	return &batchScaleSharedPoolService_ScaleSharedPoolBatch_Call{Call: _e.mock.On("ScaleSharedPoolBatch", ctx, sharedPoolId, scaleComponents, force)}
}

func (_c *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call) Run(run func(ctx context.Context, sharedPoolId string, scaleComponents []*entity.Component, force bool)) *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []*entity.Component
		if args[2] != nil {
			arg2 = args[2].([]*entity.Component)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call) Return(sharedPool *entity.SharedPool, err error) *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, scaleComponents []*entity.Component, force bool) (*entity.SharedPool, error)) *batchScaleSharedPoolService_ScaleSharedPoolBatch_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type batchScaleSharedPoolWithLockHeldService_Expecter struct {
	mock *mock.Mock
}

func (_m *batchScaleSharedPoolWithLockHeldService) EXPECT() *batchScaleSharedPoolWithLockHeldService_Expecter {
	return &batchScaleSharedPoolWithLockHeldService_Expecter{mock: &_m.Mock}
}

// ScaleSharedPoolBatchWithLockHeld provides a mock function for the type batchScaleSharedPoolWithLockHeldService
func (_mock *batchScaleSharedPoolWithLockHeldService) ScaleSharedPoolBatchWithLockHeld(ctx context.Context, sharedPoolId string, scaleComponents []*entity.Component, force bool) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, scaleComponents, force)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.Component, bool) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, scaleComponents, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.Component, bool) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, scaleComponents, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, []*entity.Component, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, scaleComponents, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ScaleSharedPoolBatchWithLockHeld is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - scaleComponents []*entity.Component
//   - force bool
func (_e *batchScaleSharedPoolWithLockHeldService_Expecter) ScaleSharedPoolBatchWithLockHeld(ctx interface{}, sharedPoolId interface{}, scaleComponents interface{}, force interface{}) *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call {
	return &batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call{Call: _e.mock.On("ScaleSharedPoolBatchWithLockHeld", ctx, sharedPoolId, scaleComponents, force)}
}

func (_c *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call) Run(run func(ctx context.Context, sharedPoolId string, scaleComponents []*entity.Component, force bool)) *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []*entity.Component
		if args[2] != nil {
			arg2 = args[2].([]*entity.Component)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call) Return(sharedPool *entity.SharedPool, err error) *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, scaleComponents []*entity.Component, force bool) (*entity.SharedPool, error)) *batchScaleSharedPoolWithLockHeldService_ScaleSharedPoolBatchWithLockHeld_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type meteringWriter_Expecter struct {
	mock *mock.Mock
}

func (_m *meteringWriter) EXPECT() *meteringWriter_Expecter {
	return &meteringWriter_Expecter{mock: &_m.Mock}
}

// Write provides a mock function for the type meteringWriter
func (_mock *meteringWriter) Write(ctx context.Context, data any) error {
	ret := _mock.Called(ctx, data)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, any) error); ok {
		r0 = returnFunc(ctx, data)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Write is a helper method to define mock.On call
//   - ctx context.Context
//   - data any
func (_e *meteringWriter_Expecter) Write(ctx interface{}, data interface{}) *meteringWriter_Write_Call {
	return &meteringWriter_Write_Call{Call: _e.mock.On("Write", ctx, data)}
}

func (_c *meteringWriter_Write_Call) Run(run func(ctx context.Context, data any)) *meteringWriter_Write_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 any
		if args[1] != nil {
			arg1 = args[1].(any)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *meteringWriter_Write_Call) Return(err error) *meteringWriter_Write_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *meteringWriter_Write_Call) RunAndReturn(run func(ctx context.Context, data any) error) *meteringWriter_Write_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type Service_Expecter struct {
	mock *mock.Mock
}

func (_m *Service) EXPECT() *Service_Expecter {
	return &Service_Expecter{mock: &_m.Mock}
}

// ApplyMaterializedAutoscalePolicies provides a mock function for the type Service
func (_mock *Service) ApplyMaterializedAutoscalePolicies(ctx context.Context, subjectType entity.AutoscalePolicySubjectType, subjectID string, policies []*entity.AutoscalePolicy) ([]*entity.AutoscalePolicy, error) {
	ret := _mock.Called(ctx, subjectType, subjectID, policies)

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

	var r0 []*entity.AutoscalePolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.AutoscalePolicySubjectType, string, []*entity.AutoscalePolicy) ([]*entity.AutoscalePolicy, error)); ok {
		return returnFunc(ctx, subjectType, subjectID, policies)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.AutoscalePolicySubjectType, string, []*entity.AutoscalePolicy) []*entity.AutoscalePolicy); ok {
		r0 = returnFunc(ctx, subjectType, subjectID, policies)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.AutoscalePolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.AutoscalePolicySubjectType, string, []*entity.AutoscalePolicy) error); ok {
		r1 = returnFunc(ctx, subjectType, subjectID, policies)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplyMaterializedAutoscalePolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - subjectType entity.AutoscalePolicySubjectType
//   - subjectID string
//   - policies []*entity.AutoscalePolicy
func (_e *Service_Expecter) ApplyMaterializedAutoscalePolicies(ctx interface{}, subjectType interface{}, subjectID interface{}, policies interface{}) *Service_ApplyMaterializedAutoscalePolicies_Call {
	return &Service_ApplyMaterializedAutoscalePolicies_Call{Call: _e.mock.On("ApplyMaterializedAutoscalePolicies", ctx, subjectType, subjectID, policies)}
}

func (_c *Service_ApplyMaterializedAutoscalePolicies_Call) Run(run func(ctx context.Context, subjectType entity.AutoscalePolicySubjectType, subjectID string, policies []*entity.AutoscalePolicy)) *Service_ApplyMaterializedAutoscalePolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.AutoscalePolicySubjectType
		if args[1] != nil {
			arg1 = args[1].(entity.AutoscalePolicySubjectType)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []*entity.AutoscalePolicy
		if args[3] != nil {
			arg3 = args[3].([]*entity.AutoscalePolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_ApplyMaterializedAutoscalePolicies_Call) Return(vs []*entity.AutoscalePolicy, err error) *Service_ApplyMaterializedAutoscalePolicies_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ApplyMaterializedAutoscalePolicies_Call) RunAndReturn(run func(ctx context.Context, subjectType entity.AutoscalePolicySubjectType, subjectID string, policies []*entity.AutoscalePolicy) ([]*entity.AutoscalePolicy, error)) *Service_ApplyMaterializedAutoscalePolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ApplySemConfig provides a mock function for the type Service
func (_mock *Service) ApplySemConfig(ctx context.Context, sharedPoolId string) error {
	ret := _mock.Called(ctx, sharedPoolId)

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

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

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

// ApplySemConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *Service_Expecter) ApplySemConfig(ctx interface{}, sharedPoolId interface{}) *Service_ApplySemConfig_Call {
	return &Service_ApplySemConfig_Call{Call: _e.mock.On("ApplySemConfig", ctx, sharedPoolId)}
}

func (_c *Service_ApplySemConfig_Call) Run(run func(ctx context.Context, sharedPoolId string)) *Service_ApplySemConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ApplySemConfig_Call) Return(err error) *Service_ApplySemConfig_Call {
	_c.Call.Return(err)
	return _c
}

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

// ApplySharedPool provides a mock function for the type Service
func (_mock *Service) ApplySharedPool(ctx context.Context, sharedPoolId string, applyComponent *entity.TargetComponent, force bool) error {
	ret := _mock.Called(ctx, sharedPoolId, applyComponent, force)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.TargetComponent, bool) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, applyComponent, force)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ApplySharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - applyComponent *entity.TargetComponent
//   - force bool
func (_e *Service_Expecter) ApplySharedPool(ctx interface{}, sharedPoolId interface{}, applyComponent interface{}, force interface{}) *Service_ApplySharedPool_Call {
	return &Service_ApplySharedPool_Call{Call: _e.mock.On("ApplySharedPool", ctx, sharedPoolId, applyComponent, force)}
}

func (_c *Service_ApplySharedPool_Call) Run(run func(ctx context.Context, sharedPoolId string, applyComponent *entity.TargetComponent, force bool)) *Service_ApplySharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *entity.TargetComponent
		if args[2] != nil {
			arg2 = args[2].(*entity.TargetComponent)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_ApplySharedPool_Call) Return(err error) *Service_ApplySharedPool_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_ApplySharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, applyComponent *entity.TargetComponent, force bool) error) *Service_ApplySharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// ApplyTiDBGroup provides a mock function for the type Service
func (_mock *Service) ApplyTiDBGroup(ctx context.Context, tidbClusterId string, tidbGroupId string, force bool) error {
	ret := _mock.Called(ctx, tidbClusterId, tidbGroupId, force)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) error); ok {
		r0 = returnFunc(ctx, tidbClusterId, tidbGroupId, force)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ApplyTiDBGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - tidbGroupId string
//   - force bool
func (_e *Service_Expecter) ApplyTiDBGroup(ctx interface{}, tidbClusterId interface{}, tidbGroupId interface{}, force interface{}) *Service_ApplyTiDBGroup_Call {
	return &Service_ApplyTiDBGroup_Call{Call: _e.mock.On("ApplyTiDBGroup", ctx, tidbClusterId, tidbGroupId, force)}
}

func (_c *Service_ApplyTiDBGroup_Call) Run(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, force bool)) *Service_ApplyTiDBGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_ApplyTiDBGroup_Call) Return(err error) *Service_ApplyTiDBGroup_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_ApplyTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, force bool) error) *Service_ApplyTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CancelExport provides a mock function for the type Service
func (_mock *Service) CancelExport(ctx context.Context, clusterId string, exportId string) (*entity.Export, error) {
	ret := _mock.Called(ctx, clusterId, exportId)

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

	var r0 *entity.Export
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.Export, error)); ok {
		return returnFunc(ctx, clusterId, exportId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.Export); ok {
		r0 = returnFunc(ctx, clusterId, exportId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Export)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, clusterId, exportId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *Service_CancelExport_Call) Run(run func(ctx context.Context, clusterId string, exportId string)) *Service_CancelExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_CancelExport_Call) Return(v *entity.Export, err error) *Service_CancelExport_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CancelExport_Call) RunAndReturn(run func(ctx context.Context, clusterId string, exportId string) (*entity.Export, error)) *Service_CancelExport_Call {
	_c.Call.Return(run)
	return _c
}

// CancelScaleOperation provides a mock function for the type Service
func (_mock *Service) CancelScaleOperation(ctx context.Context, sharedPoolID string, scaleOperationID string, reason string) (*entity.ScaleOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID, scaleOperationID, reason)

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

	var r0 *entity.ScaleOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.ScaleOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID, scaleOperationID, reason)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.ScaleOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID, scaleOperationID, reason)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ScaleOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, scaleOperationID, reason)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CancelScaleOperation is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - scaleOperationID string
//   - reason string
func (_e *Service_Expecter) CancelScaleOperation(ctx interface{}, sharedPoolID interface{}, scaleOperationID interface{}, reason interface{}) *Service_CancelScaleOperation_Call {
	return &Service_CancelScaleOperation_Call{Call: _e.mock.On("CancelScaleOperation", ctx, sharedPoolID, scaleOperationID, reason)}
}

func (_c *Service_CancelScaleOperation_Call) Run(run func(ctx context.Context, sharedPoolID string, scaleOperationID string, reason string)) *Service_CancelScaleOperation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_CancelScaleOperation_Call) Return(scaleOperation *entity.ScaleOperation, err error) *Service_CancelScaleOperation_Call {
	_c.Call.Return(scaleOperation, err)
	return _c
}

func (_c *Service_CancelScaleOperation_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, scaleOperationID string, reason string) (*entity.ScaleOperation, error)) *Service_CancelScaleOperation_Call {
	_c.Call.Return(run)
	return _c
}

// CheckPods provides a mock function for the type Service
func (_mock *Service) CheckPods(ctx context.Context, sharedPoolId string, clusterId string, componentType entity.ComponentType, form string) (*entity.CheckPodsResponse, error) {
	ret := _mock.Called(ctx, sharedPoolId, clusterId, componentType, form)

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

	var r0 *entity.CheckPodsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.ComponentType, string) (*entity.CheckPodsResponse, error)); ok {
		return returnFunc(ctx, sharedPoolId, clusterId, componentType, form)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.ComponentType, string) *entity.CheckPodsResponse); ok {
		r0 = returnFunc(ctx, sharedPoolId, clusterId, componentType, form)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.CheckPodsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, entity.ComponentType, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, clusterId, componentType, form)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CheckPods is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - clusterId string
//   - componentType entity.ComponentType
//   - form string
func (_e *Service_Expecter) CheckPods(ctx interface{}, sharedPoolId interface{}, clusterId interface{}, componentType interface{}, form interface{}) *Service_CheckPods_Call {
	return &Service_CheckPods_Call{Call: _e.mock.On("CheckPods", ctx, sharedPoolId, clusterId, componentType, form)}
}

func (_c *Service_CheckPods_Call) Run(run func(ctx context.Context, sharedPoolId string, clusterId string, componentType entity.ComponentType, form string)) *Service_CheckPods_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.ComponentType
		if args[3] != nil {
			arg3 = args[3].(entity.ComponentType)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_CheckPods_Call) Return(v *entity.CheckPodsResponse, err error) *Service_CheckPods_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CheckPods_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, clusterId string, componentType entity.ComponentType, form string) (*entity.CheckPodsResponse, error)) *Service_CheckPods_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClassicRestore provides a mock function for the type Service
func (_mock *Service) CreateClassicRestore(ctx context.Context, req *server.CreateClassicRestoreInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.CreateClassicRestoreInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateClassicRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.CreateClassicRestoreInput
func (_e *Service_Expecter) CreateClassicRestore(ctx interface{}, req interface{}) *Service_CreateClassicRestore_Call {
	return &Service_CreateClassicRestore_Call{Call: _e.mock.On("CreateClassicRestore", ctx, req)}
}

func (_c *Service_CreateClassicRestore_Call) Run(run func(ctx context.Context, req *server.CreateClassicRestoreInput)) *Service_CreateClassicRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.CreateClassicRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*server.CreateClassicRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateClassicRestore_Call) Return(err error) *Service_CreateClassicRestore_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_CreateClassicRestore_Call) RunAndReturn(run func(ctx context.Context, req *server.CreateClassicRestoreInput) error) *Service_CreateClassicRestore_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDMCluster provides a mock function for the type Service
func (_mock *Service) CreateDMCluster(ctx context.Context, dmCluster *entity.DMCluster) (*entity.DMCluster, error) {
	ret := _mock.Called(ctx, dmCluster)

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

	var r0 *entity.DMCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.DMCluster) (*entity.DMCluster, error)); ok {
		return returnFunc(ctx, dmCluster)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.DMCluster) *entity.DMCluster); ok {
		r0 = returnFunc(ctx, dmCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DMCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.DMCluster) error); ok {
		r1 = returnFunc(ctx, dmCluster)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateDMCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - dmCluster *entity.DMCluster
func (_e *Service_Expecter) CreateDMCluster(ctx interface{}, dmCluster interface{}) *Service_CreateDMCluster_Call {
	return &Service_CreateDMCluster_Call{Call: _e.mock.On("CreateDMCluster", ctx, dmCluster)}
}

func (_c *Service_CreateDMCluster_Call) Run(run func(ctx context.Context, dmCluster *entity.DMCluster)) *Service_CreateDMCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.DMCluster
		if args[1] != nil {
			arg1 = args[1].(*entity.DMCluster)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateDMCluster_Call) Return(v *entity.DMCluster, err error) *Service_CreateDMCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateDMCluster_Call) RunAndReturn(run func(ctx context.Context, dmCluster *entity.DMCluster) (*entity.DMCluster, error)) *Service_CreateDMCluster_Call {
	_c.Call.Return(run)
	return _c
}

// CreateExport provides a mock function for the type Service
func (_mock *Service) CreateExport(ctx context.Context, export *entity.Export) (*entity.Export, error) {
	ret := _mock.Called(ctx, export)

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

	var r0 *entity.Export
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Export) (*entity.Export, error)); ok {
		return returnFunc(ctx, export)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Export) *entity.Export); ok {
		r0 = returnFunc(ctx, export)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Export)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.Export) error); ok {
		r1 = returnFunc(ctx, export)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateExport is a helper method to define mock.On call
//   - ctx context.Context
//   - export *entity.Export
func (_e *Service_Expecter) CreateExport(ctx interface{}, export interface{}) *Service_CreateExport_Call {
	return &Service_CreateExport_Call{Call: _e.mock.On("CreateExport", ctx, export)}
}

func (_c *Service_CreateExport_Call) Run(run func(ctx context.Context, export *entity.Export)) *Service_CreateExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.Export
		if args[1] != nil {
			arg1 = args[1].(*entity.Export)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateExport_Call) Return(v *entity.Export, err error) *Service_CreateExport_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateExport_Call) RunAndReturn(run func(ctx context.Context, export *entity.Export) (*entity.Export, error)) *Service_CreateExport_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLightweightRestore provides a mock function for the type Service
func (_mock *Service) CreateLightweightRestore(ctx context.Context, req *br.CreateLightweightRestoreInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *br.CreateLightweightRestoreInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateLightweightRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *br.CreateLightweightRestoreInput
func (_e *Service_Expecter) CreateLightweightRestore(ctx interface{}, req interface{}) *Service_CreateLightweightRestore_Call {
	return &Service_CreateLightweightRestore_Call{Call: _e.mock.On("CreateLightweightRestore", ctx, req)}
}

func (_c *Service_CreateLightweightRestore_Call) Run(run func(ctx context.Context, req *br.CreateLightweightRestoreInput)) *Service_CreateLightweightRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *br.CreateLightweightRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*br.CreateLightweightRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateLightweightRestore_Call) Return(err error) *Service_CreateLightweightRestore_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_CreateLightweightRestore_Call) RunAndReturn(run func(ctx context.Context, req *br.CreateLightweightRestoreInput) error) *Service_CreateLightweightRestore_Call {
	_c.Call.Return(run)
	return _c
}

// CreateManualBackup provides a mock function for the type Service
func (_mock *Service) CreateManualBackup(ctx context.Context, req *server.CreateManualBackupInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.CreateManualBackupInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateManualBackup is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.CreateManualBackupInput
func (_e *Service_Expecter) CreateManualBackup(ctx interface{}, req interface{}) *Service_CreateManualBackup_Call {
	return &Service_CreateManualBackup_Call{Call: _e.mock.On("CreateManualBackup", ctx, req)}
}

func (_c *Service_CreateManualBackup_Call) Run(run func(ctx context.Context, req *server.CreateManualBackupInput)) *Service_CreateManualBackup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.CreateManualBackupInput
		if args[1] != nil {
			arg1 = args[1].(*server.CreateManualBackupInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateManualBackup_Call) Return(err error) *Service_CreateManualBackup_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_CreateManualBackup_Call) RunAndReturn(run func(ctx context.Context, req *server.CreateManualBackupInput) error) *Service_CreateManualBackup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateManualBackupRestore provides a mock function for the type Service
func (_mock *Service) CreateManualBackupRestore(ctx context.Context, req *server.CreateManualBackupRestoreInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.CreateManualBackupRestoreInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateManualBackupRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.CreateManualBackupRestoreInput
func (_e *Service_Expecter) CreateManualBackupRestore(ctx interface{}, req interface{}) *Service_CreateManualBackupRestore_Call {
	return &Service_CreateManualBackupRestore_Call{Call: _e.mock.On("CreateManualBackupRestore", ctx, req)}
}

func (_c *Service_CreateManualBackupRestore_Call) Run(run func(ctx context.Context, req *server.CreateManualBackupRestoreInput)) *Service_CreateManualBackupRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.CreateManualBackupRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*server.CreateManualBackupRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateManualBackupRestore_Call) Return(err error) *Service_CreateManualBackupRestore_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_CreateManualBackupRestore_Call) RunAndReturn(run func(ctx context.Context, req *server.CreateManualBackupRestoreInput) error) *Service_CreateManualBackupRestore_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNodeInstanceGroup provides a mock function for the type Service
func (_mock *Service) CreateNodeInstanceGroup(ctx context.Context, group *entity.NodeInstanceGroup) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, group)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.NodeInstanceGroup) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, group)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.NodeInstanceGroup) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, group)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.NodeInstanceGroup) error); ok {
		r1 = returnFunc(ctx, group)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateNodeInstanceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - group *entity.NodeInstanceGroup
func (_e *Service_Expecter) CreateNodeInstanceGroup(ctx interface{}, group interface{}) *Service_CreateNodeInstanceGroup_Call {
	return &Service_CreateNodeInstanceGroup_Call{Call: _e.mock.On("CreateNodeInstanceGroup", ctx, group)}
}

func (_c *Service_CreateNodeInstanceGroup_Call) Run(run func(ctx context.Context, group *entity.NodeInstanceGroup)) *Service_CreateNodeInstanceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.NodeInstanceGroup
		if args[1] != nil {
			arg1 = args[1].(*entity.NodeInstanceGroup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateNodeInstanceGroup_Call) Return(v *entity.NodeInstanceGroup, err error) *Service_CreateNodeInstanceGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateNodeInstanceGroup_Call) RunAndReturn(run func(ctx context.Context, group *entity.NodeInstanceGroup) (*entity.NodeInstanceGroup, error)) *Service_CreateNodeInstanceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOrReplaceAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) CreateOrReplaceAutoscalePolicy(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, applyToAllSharedPools *wrapperspb.BoolValue, requestID string) (*entity.AutoscalePolicyResponse, error) {
	ret := _mock.Called(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)

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

	var r0 *entity.AutoscalePolicyResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, *wrapperspb.BoolValue, string) (*entity.AutoscalePolicyResponse, error)); ok {
		return returnFunc(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, *wrapperspb.BoolValue, string) *entity.AutoscalePolicyResponse); ok {
		r0 = returnFunc(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscalePolicyResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, *wrapperspb.BoolValue, string) error); ok {
		r1 = returnFunc(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateOrReplaceAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
//   - specs []*entity.AutoscalePolicySpec
//   - applyToAllSharedPools *wrapperspb.BoolValue
//   - requestID string
func (_e *Service_Expecter) CreateOrReplaceAutoscalePolicy(ctx interface{}, scope interface{}, subjectID interface{}, specs interface{}, applyToAllSharedPools interface{}, requestID interface{}) *Service_CreateOrReplaceAutoscalePolicy_Call {
	return &Service_CreateOrReplaceAutoscalePolicy_Call{Call: _e.mock.On("CreateOrReplaceAutoscalePolicy", ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)}
}

func (_c *Service_CreateOrReplaceAutoscalePolicy_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, applyToAllSharedPools *wrapperspb.BoolValue, requestID string)) *Service_CreateOrReplaceAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []*entity.AutoscalePolicySpec
		if args[3] != nil {
			arg3 = args[3].([]*entity.AutoscalePolicySpec)
		}
		var arg4 *wrapperspb.BoolValue
		if args[4] != nil {
			arg4 = args[4].(*wrapperspb.BoolValue)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_CreateOrReplaceAutoscalePolicy_Call) Return(v *entity.AutoscalePolicyResponse, err error) *Service_CreateOrReplaceAutoscalePolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateOrReplaceAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, applyToAllSharedPools *wrapperspb.BoolValue, requestID string) (*entity.AutoscalePolicyResponse, error)) *Service_CreateOrReplaceAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePlacementPolicy provides a mock function for the type Service
func (_mock *Service) CreatePlacementPolicy(ctx context.Context, sharedPoolId string, clusterId string, tikvGroupId string) (*entity.PlacementPolicy, error) {
	ret := _mock.Called(ctx, sharedPoolId, clusterId, tikvGroupId)

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

	var r0 *entity.PlacementPolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.PlacementPolicy, error)); ok {
		return returnFunc(ctx, sharedPoolId, clusterId, tikvGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.PlacementPolicy); ok {
		r0 = returnFunc(ctx, sharedPoolId, clusterId, tikvGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PlacementPolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, clusterId, tikvGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreatePlacementPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - clusterId string
//   - tikvGroupId string
func (_e *Service_Expecter) CreatePlacementPolicy(ctx interface{}, sharedPoolId interface{}, clusterId interface{}, tikvGroupId interface{}) *Service_CreatePlacementPolicy_Call {
	return &Service_CreatePlacementPolicy_Call{Call: _e.mock.On("CreatePlacementPolicy", ctx, sharedPoolId, clusterId, tikvGroupId)}
}

func (_c *Service_CreatePlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, clusterId string, tikvGroupId string)) *Service_CreatePlacementPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_CreatePlacementPolicy_Call) Return(v *entity.PlacementPolicy, err error) *Service_CreatePlacementPolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreatePlacementPolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, clusterId string, tikvGroupId string) (*entity.PlacementPolicy, error)) *Service_CreatePlacementPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateLinkService provides a mock function for the type Service
func (_mock *Service) CreatePrivateLinkService(ctx context.Context, tidbClusterId string, privateLinkService *entity.PrivateLinkService) (*entity.PrivateLinkService, error) {
	ret := _mock.Called(ctx, tidbClusterId, privateLinkService)

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

	var r0 *entity.PrivateLinkService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.PrivateLinkService) (*entity.PrivateLinkService, error)); ok {
		return returnFunc(ctx, tidbClusterId, privateLinkService)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.PrivateLinkService) *entity.PrivateLinkService); ok {
		r0 = returnFunc(ctx, tidbClusterId, privateLinkService)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PrivateLinkService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.PrivateLinkService) error); ok {
		r1 = returnFunc(ctx, tidbClusterId, privateLinkService)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreatePrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - privateLinkService *entity.PrivateLinkService
func (_e *Service_Expecter) CreatePrivateLinkService(ctx interface{}, tidbClusterId interface{}, privateLinkService interface{}) *Service_CreatePrivateLinkService_Call {
	return &Service_CreatePrivateLinkService_Call{Call: _e.mock.On("CreatePrivateLinkService", ctx, tidbClusterId, privateLinkService)}
}

func (_c *Service_CreatePrivateLinkService_Call) Run(run func(ctx context.Context, tidbClusterId string, privateLinkService *entity.PrivateLinkService)) *Service_CreatePrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *entity.PrivateLinkService
		if args[2] != nil {
			arg2 = args[2].(*entity.PrivateLinkService)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_CreatePrivateLinkService_Call) Return(v *entity.PrivateLinkService, err error) *Service_CreatePrivateLinkService_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreatePrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, privateLinkService *entity.PrivateLinkService) (*entity.PrivateLinkService, error)) *Service_CreatePrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSharedPool provides a mock function for the type Service
func (_mock *Service) CreateSharedPool(ctx context.Context, sharedPool *entity.SharedPool, requestUint *entity.RequestUnit, initConfig *entity.InitSharedPoolConfig, options ...*server.CreateSharedPoolOptions) (*entity.SharedPool, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, sharedPool, requestUint, initConfig, options)
	} else {
		tmpRet = _mock.Called(ctx, sharedPool, requestUint, initConfig)
	}
	ret := tmpRet

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, *entity.RequestUnit, *entity.InitSharedPoolConfig, ...*server.CreateSharedPoolOptions) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPool, requestUint, initConfig, options...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, *entity.RequestUnit, *entity.InitSharedPoolConfig, ...*server.CreateSharedPoolOptions) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPool, requestUint, initConfig, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.SharedPool, *entity.RequestUnit, *entity.InitSharedPoolConfig, ...*server.CreateSharedPoolOptions) error); ok {
		r1 = returnFunc(ctx, sharedPool, requestUint, initConfig, options...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - requestUint *entity.RequestUnit
//   - initConfig *entity.InitSharedPoolConfig
//   - options ...*server.CreateSharedPoolOptions
func (_e *Service_Expecter) CreateSharedPool(ctx interface{}, sharedPool interface{}, requestUint interface{}, initConfig interface{}, options ...interface{}) *Service_CreateSharedPool_Call {
	return &Service_CreateSharedPool_Call{Call: _e.mock.On("CreateSharedPool",
		append([]interface{}{ctx, sharedPool, requestUint, initConfig}, options...)...)}
}

func (_c *Service_CreateSharedPool_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, requestUint *entity.RequestUnit, initConfig *entity.InitSharedPoolConfig, options ...*server.CreateSharedPoolOptions)) *Service_CreateSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *entity.RequestUnit
		if args[2] != nil {
			arg2 = args[2].(*entity.RequestUnit)
		}
		var arg3 *entity.InitSharedPoolConfig
		if args[3] != nil {
			arg3 = args[3].(*entity.InitSharedPoolConfig)
		}
		var arg4 []*server.CreateSharedPoolOptions
		var variadicArgs []*server.CreateSharedPoolOptions
		if len(args) > 4 {
			variadicArgs = args[4].([]*server.CreateSharedPoolOptions)
		}
		arg4 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4...,
		)
	})
	return _c
}

func (_c *Service_CreateSharedPool_Call) Return(sharedPool1 *entity.SharedPool, err error) *Service_CreateSharedPool_Call {
	_c.Call.Return(sharedPool1, err)
	return _c
}

func (_c *Service_CreateSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, requestUint *entity.RequestUnit, initConfig *entity.InitSharedPoolConfig, options ...*server.CreateSharedPoolOptions) (*entity.SharedPool, error)) *Service_CreateSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTiDBCluster provides a mock function for the type Service
func (_mock *Service) CreateTiDBCluster(ctx context.Context, tidbCluster *entity.TiDBCluster) (*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, tidbCluster)

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

	var r0 *entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBCluster) (*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, tidbCluster)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBCluster) *entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, tidbCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.TiDBCluster) error); ok {
		r1 = returnFunc(ctx, tidbCluster)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateTiDBCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbCluster *entity.TiDBCluster
func (_e *Service_Expecter) CreateTiDBCluster(ctx interface{}, tidbCluster interface{}) *Service_CreateTiDBCluster_Call {
	return &Service_CreateTiDBCluster_Call{Call: _e.mock.On("CreateTiDBCluster", ctx, tidbCluster)}
}

func (_c *Service_CreateTiDBCluster_Call) Run(run func(ctx context.Context, tidbCluster *entity.TiDBCluster)) *Service_CreateTiDBCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TiDBCluster
		if args[1] != nil {
			arg1 = args[1].(*entity.TiDBCluster)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateTiDBCluster_Call) Return(v *entity.TiDBCluster, err error) *Service_CreateTiDBCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateTiDBCluster_Call) RunAndReturn(run func(ctx context.Context, tidbCluster *entity.TiDBCluster) (*entity.TiDBCluster, error)) *Service_CreateTiDBCluster_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTiDBGroup provides a mock function for the type Service
func (_mock *Service) CreateTiDBGroup(ctx context.Context, tidbGroup *entity.TiDBGroup) (*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, tidbGroup)

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

	var r0 *entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBGroup) (*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, tidbGroup)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBGroup) *entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, tidbGroup)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.TiDBGroup) error); ok {
		r1 = returnFunc(ctx, tidbGroup)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateTiDBGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbGroup *entity.TiDBGroup
func (_e *Service_Expecter) CreateTiDBGroup(ctx interface{}, tidbGroup interface{}) *Service_CreateTiDBGroup_Call {
	return &Service_CreateTiDBGroup_Call{Call: _e.mock.On("CreateTiDBGroup", ctx, tidbGroup)}
}

func (_c *Service_CreateTiDBGroup_Call) Run(run func(ctx context.Context, tidbGroup *entity.TiDBGroup)) *Service_CreateTiDBGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TiDBGroup
		if args[1] != nil {
			arg1 = args[1].(*entity.TiDBGroup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateTiDBGroup_Call) Return(tiDBGroup *entity.TiDBGroup, err error) *Service_CreateTiDBGroup_Call {
	_c.Call.Return(tiDBGroup, err)
	return _c
}

func (_c *Service_CreateTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, tidbGroup *entity.TiDBGroup) (*entity.TiDBGroup, error)) *Service_CreateTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTiKVCapacityReservation provides a mock function for the type Service
func (_mock *Service) CreateTiKVCapacityReservation(ctx context.Context, req *server.CreateTiKVCapacityReservationInput) (*entity.TiKVCapacityReservation, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *entity.TiKVCapacityReservation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.CreateTiKVCapacityReservationInput) (*entity.TiKVCapacityReservation, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.CreateTiKVCapacityReservationInput) *entity.TiKVCapacityReservation); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiKVCapacityReservation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.CreateTiKVCapacityReservationInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateTiKVCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.CreateTiKVCapacityReservationInput
func (_e *Service_Expecter) CreateTiKVCapacityReservation(ctx interface{}, req interface{}) *Service_CreateTiKVCapacityReservation_Call {
	return &Service_CreateTiKVCapacityReservation_Call{Call: _e.mock.On("CreateTiKVCapacityReservation", ctx, req)}
}

func (_c *Service_CreateTiKVCapacityReservation_Call) Run(run func(ctx context.Context, req *server.CreateTiKVCapacityReservationInput)) *Service_CreateTiKVCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.CreateTiKVCapacityReservationInput
		if args[1] != nil {
			arg1 = args[1].(*server.CreateTiKVCapacityReservationInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_CreateTiKVCapacityReservation_Call) Return(v *entity.TiKVCapacityReservation, err error) *Service_CreateTiKVCapacityReservation_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateTiKVCapacityReservation_Call) RunAndReturn(run func(ctx context.Context, req *server.CreateTiKVCapacityReservationInput) (*entity.TiKVCapacityReservation, error)) *Service_CreateTiKVCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTiKVGroup provides a mock function for the type Service
func (_mock *Service) CreateTiKVGroup(ctx context.Context, sharedPoolId string, tikvGroupId string, nodeQuota *entity.NodeQuota, storages []*entity.Storage, labels map[string]string, exclusive bool, force bool) (*entity.Component, error) {
	ret := _mock.Called(ctx, sharedPoolId, tikvGroupId, nodeQuota, storages, labels, exclusive, force)

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

	var r0 *entity.Component
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.NodeQuota, []*entity.Storage, map[string]string, bool, bool) (*entity.Component, error)); ok {
		return returnFunc(ctx, sharedPoolId, tikvGroupId, nodeQuota, storages, labels, exclusive, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.NodeQuota, []*entity.Storage, map[string]string, bool, bool) *entity.Component); ok {
		r0 = returnFunc(ctx, sharedPoolId, tikvGroupId, nodeQuota, storages, labels, exclusive, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Component)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *entity.NodeQuota, []*entity.Storage, map[string]string, bool, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, tikvGroupId, nodeQuota, storages, labels, exclusive, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateTiKVGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - tikvGroupId string
//   - nodeQuota *entity.NodeQuota
//   - storages []*entity.Storage
//   - labels map[string]string
//   - exclusive bool
//   - force bool
func (_e *Service_Expecter) CreateTiKVGroup(ctx interface{}, sharedPoolId interface{}, tikvGroupId interface{}, nodeQuota interface{}, storages interface{}, labels interface{}, exclusive interface{}, force interface{}) *Service_CreateTiKVGroup_Call {
	return &Service_CreateTiKVGroup_Call{Call: _e.mock.On("CreateTiKVGroup", ctx, sharedPoolId, tikvGroupId, nodeQuota, storages, labels, exclusive, force)}
}

func (_c *Service_CreateTiKVGroup_Call) Run(run func(ctx context.Context, sharedPoolId string, tikvGroupId string, nodeQuota *entity.NodeQuota, storages []*entity.Storage, labels map[string]string, exclusive bool, force bool)) *Service_CreateTiKVGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *entity.NodeQuota
		if args[3] != nil {
			arg3 = args[3].(*entity.NodeQuota)
		}
		var arg4 []*entity.Storage
		if args[4] != nil {
			arg4 = args[4].([]*entity.Storage)
		}
		var arg5 map[string]string
		if args[5] != nil {
			arg5 = args[5].(map[string]string)
		}
		var arg6 bool
		if args[6] != nil {
			arg6 = args[6].(bool)
		}
		var arg7 bool
		if args[7] != nil {
			arg7 = args[7].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6,
			arg7,
		)
	})
	return _c
}

func (_c *Service_CreateTiKVGroup_Call) Return(v *entity.Component, err error) *Service_CreateTiKVGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_CreateTiKVGroup_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, tikvGroupId string, nodeQuota *entity.NodeQuota, storages []*entity.Storage, labels map[string]string, exclusive bool, force bool) (*entity.Component, error)) *Service_CreateTiKVGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAutoscaleRuntimeGuard provides a mock function for the type Service
func (_mock *Service) DeleteAutoscaleRuntimeGuard(ctx context.Context, scopeType entity.AutoscaleRuntimeGuardScopeType, scopeID string, guardType entity.AutoscaleRuntimeGuardType, componentType entity.ComponentType) error {
	ret := _mock.Called(ctx, scopeType, scopeID, guardType, componentType)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.AutoscaleRuntimeGuardScopeType, string, entity.AutoscaleRuntimeGuardType, entity.ComponentType) error); ok {
		r0 = returnFunc(ctx, scopeType, scopeID, guardType, componentType)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteAutoscaleRuntimeGuard is a helper method to define mock.On call
//   - ctx context.Context
//   - scopeType entity.AutoscaleRuntimeGuardScopeType
//   - scopeID string
//   - guardType entity.AutoscaleRuntimeGuardType
//   - componentType entity.ComponentType
func (_e *Service_Expecter) DeleteAutoscaleRuntimeGuard(ctx interface{}, scopeType interface{}, scopeID interface{}, guardType interface{}, componentType interface{}) *Service_DeleteAutoscaleRuntimeGuard_Call {
	return &Service_DeleteAutoscaleRuntimeGuard_Call{Call: _e.mock.On("DeleteAutoscaleRuntimeGuard", ctx, scopeType, scopeID, guardType, componentType)}
}

func (_c *Service_DeleteAutoscaleRuntimeGuard_Call) Run(run func(ctx context.Context, scopeType entity.AutoscaleRuntimeGuardScopeType, scopeID string, guardType entity.AutoscaleRuntimeGuardType, componentType entity.ComponentType)) *Service_DeleteAutoscaleRuntimeGuard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.AutoscaleRuntimeGuardScopeType
		if args[1] != nil {
			arg1 = args[1].(entity.AutoscaleRuntimeGuardScopeType)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.AutoscaleRuntimeGuardType
		if args[3] != nil {
			arg3 = args[3].(entity.AutoscaleRuntimeGuardType)
		}
		var arg4 entity.ComponentType
		if args[4] != nil {
			arg4 = args[4].(entity.ComponentType)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_DeleteAutoscaleRuntimeGuard_Call) Return(err error) *Service_DeleteAutoscaleRuntimeGuard_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteAutoscaleRuntimeGuard_Call) RunAndReturn(run func(ctx context.Context, scopeType entity.AutoscaleRuntimeGuardScopeType, scopeID string, guardType entity.AutoscaleRuntimeGuardType, componentType entity.ComponentType) error) *Service_DeleteAutoscaleRuntimeGuard_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClassicRestore provides a mock function for the type Service
func (_mock *Service) DeleteClassicRestore(ctx context.Context, req *server.DeleteClassicRestoreInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.DeleteClassicRestoreInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteClassicRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.DeleteClassicRestoreInput
func (_e *Service_Expecter) DeleteClassicRestore(ctx interface{}, req interface{}) *Service_DeleteClassicRestore_Call {
	return &Service_DeleteClassicRestore_Call{Call: _e.mock.On("DeleteClassicRestore", ctx, req)}
}

func (_c *Service_DeleteClassicRestore_Call) Run(run func(ctx context.Context, req *server.DeleteClassicRestoreInput)) *Service_DeleteClassicRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.DeleteClassicRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*server.DeleteClassicRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_DeleteClassicRestore_Call) Return(err error) *Service_DeleteClassicRestore_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteClassicRestore_Call) RunAndReturn(run func(ctx context.Context, req *server.DeleteClassicRestoreInput) error) *Service_DeleteClassicRestore_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDMCluster provides a mock function for the type Service
func (_mock *Service) DeleteDMCluster(ctx context.Context, sharedPoolId string, dmClusterId string) error {
	ret := _mock.Called(ctx, sharedPoolId, dmClusterId)

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

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

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

// DeleteDMCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - dmClusterId string
func (_e *Service_Expecter) DeleteDMCluster(ctx interface{}, sharedPoolId interface{}, dmClusterId interface{}) *Service_DeleteDMCluster_Call {
	return &Service_DeleteDMCluster_Call{Call: _e.mock.On("DeleteDMCluster", ctx, sharedPoolId, dmClusterId)}
}

func (_c *Service_DeleteDMCluster_Call) Run(run func(ctx context.Context, sharedPoolId string, dmClusterId string)) *Service_DeleteDMCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeleteDMCluster_Call) Return(err error) *Service_DeleteDMCluster_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteDMCluster_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, dmClusterId string) error) *Service_DeleteDMCluster_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLightweightRestore provides a mock function for the type Service
func (_mock *Service) DeleteLightweightRestore(ctx context.Context, req *br.DeleteLightweightRestoreInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *br.DeleteLightweightRestoreInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteLightweightRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *br.DeleteLightweightRestoreInput
func (_e *Service_Expecter) DeleteLightweightRestore(ctx interface{}, req interface{}) *Service_DeleteLightweightRestore_Call {
	return &Service_DeleteLightweightRestore_Call{Call: _e.mock.On("DeleteLightweightRestore", ctx, req)}
}

func (_c *Service_DeleteLightweightRestore_Call) Run(run func(ctx context.Context, req *br.DeleteLightweightRestoreInput)) *Service_DeleteLightweightRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *br.DeleteLightweightRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*br.DeleteLightweightRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_DeleteLightweightRestore_Call) Return(err error) *Service_DeleteLightweightRestore_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteLightweightRestore_Call) RunAndReturn(run func(ctx context.Context, req *br.DeleteLightweightRestoreInput) error) *Service_DeleteLightweightRestore_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteManualBackup provides a mock function for the type Service
func (_mock *Service) DeleteManualBackup(ctx context.Context, req *server.DeleteManualBackupInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.DeleteManualBackupInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteManualBackup is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.DeleteManualBackupInput
func (_e *Service_Expecter) DeleteManualBackup(ctx interface{}, req interface{}) *Service_DeleteManualBackup_Call {
	return &Service_DeleteManualBackup_Call{Call: _e.mock.On("DeleteManualBackup", ctx, req)}
}

func (_c *Service_DeleteManualBackup_Call) Run(run func(ctx context.Context, req *server.DeleteManualBackupInput)) *Service_DeleteManualBackup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.DeleteManualBackupInput
		if args[1] != nil {
			arg1 = args[1].(*server.DeleteManualBackupInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_DeleteManualBackup_Call) Return(err error) *Service_DeleteManualBackup_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteManualBackup_Call) RunAndReturn(run func(ctx context.Context, req *server.DeleteManualBackupInput) error) *Service_DeleteManualBackup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteManualBackupRestore provides a mock function for the type Service
func (_mock *Service) DeleteManualBackupRestore(ctx context.Context, req *server.DeleteManualBackupRestoreInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.DeleteManualBackupRestoreInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteManualBackupRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.DeleteManualBackupRestoreInput
func (_e *Service_Expecter) DeleteManualBackupRestore(ctx interface{}, req interface{}) *Service_DeleteManualBackupRestore_Call {
	return &Service_DeleteManualBackupRestore_Call{Call: _e.mock.On("DeleteManualBackupRestore", ctx, req)}
}

func (_c *Service_DeleteManualBackupRestore_Call) Run(run func(ctx context.Context, req *server.DeleteManualBackupRestoreInput)) *Service_DeleteManualBackupRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.DeleteManualBackupRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*server.DeleteManualBackupRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_DeleteManualBackupRestore_Call) Return(err error) *Service_DeleteManualBackupRestore_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteManualBackupRestore_Call) RunAndReturn(run func(ctx context.Context, req *server.DeleteManualBackupRestoreInput) error) *Service_DeleteManualBackupRestore_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNodeInstanceGroup provides a mock function for the type Service
func (_mock *Service) DeleteNodeInstanceGroup(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteNodeInstanceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
func (_e *Service_Expecter) DeleteNodeInstanceGroup(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}) *Service_DeleteNodeInstanceGroup_Call {
	return &Service_DeleteNodeInstanceGroup_Call{Call: _e.mock.On("DeleteNodeInstanceGroup", ctx, nodeSpec, primaryInstance)}
}

func (_c *Service_DeleteNodeInstanceGroup_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string)) *Service_DeleteNodeInstanceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeleteNodeInstanceGroup_Call) Return(v *entity.NodeInstanceGroup, err error) *Service_DeleteNodeInstanceGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_DeleteNodeInstanceGroup_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error)) *Service_DeleteNodeInstanceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePlacementPolicy provides a mock function for the type Service
func (_mock *Service) DeletePlacementPolicy(ctx context.Context, sharedPoolId string, placementPolicyId string) error {
	ret := _mock.Called(ctx, sharedPoolId, placementPolicyId)

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

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

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

// DeletePlacementPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - placementPolicyId string
func (_e *Service_Expecter) DeletePlacementPolicy(ctx interface{}, sharedPoolId interface{}, placementPolicyId interface{}) *Service_DeletePlacementPolicy_Call {
	return &Service_DeletePlacementPolicy_Call{Call: _e.mock.On("DeletePlacementPolicy", ctx, sharedPoolId, placementPolicyId)}
}

func (_c *Service_DeletePlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, placementPolicyId string)) *Service_DeletePlacementPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeletePlacementPolicy_Call) Return(err error) *Service_DeletePlacementPolicy_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeletePlacementPolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, placementPolicyId string) error) *Service_DeletePlacementPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePrivateLinkService provides a mock function for the type Service
func (_mock *Service) DeletePrivateLinkService(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string) error {
	ret := _mock.Called(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeletePrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - tidbGroupId string
//   - privateLinkServiceId string
func (_e *Service_Expecter) DeletePrivateLinkService(ctx interface{}, tidbClusterId interface{}, tidbGroupId interface{}, privateLinkServiceId interface{}) *Service_DeletePrivateLinkService_Call {
	return &Service_DeletePrivateLinkService_Call{Call: _e.mock.On("DeletePrivateLinkService", ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)}
}

func (_c *Service_DeletePrivateLinkService_Call) Run(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string)) *Service_DeletePrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_DeletePrivateLinkService_Call) Return(err error) *Service_DeletePrivateLinkService_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeletePrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string) error) *Service_DeletePrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSharedPool provides a mock function for the type Service
func (_mock *Service) DeleteSharedPool(ctx context.Context, sharedPoolId string, pruneDataplane bool) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, pruneDataplane)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, pruneDataplane)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, pruneDataplane)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, pruneDataplane)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - pruneDataplane bool
func (_e *Service_Expecter) DeleteSharedPool(ctx interface{}, sharedPoolId interface{}, pruneDataplane interface{}) *Service_DeleteSharedPool_Call {
	return &Service_DeleteSharedPool_Call{Call: _e.mock.On("DeleteSharedPool", ctx, sharedPoolId, pruneDataplane)}
}

func (_c *Service_DeleteSharedPool_Call) Run(run func(ctx context.Context, sharedPoolId string, pruneDataplane bool)) *Service_DeleteSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeleteSharedPool_Call) Return(sharedPool *entity.SharedPool, err error) *Service_DeleteSharedPool_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_DeleteSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, pruneDataplane bool) (*entity.SharedPool, error)) *Service_DeleteSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTiDBCluster provides a mock function for the type Service
func (_mock *Service) DeleteTiDBCluster(ctx context.Context, tidbClusterId string) (*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, tidbClusterId)

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

	var r0 *entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, tidbClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, tidbClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteTiDBCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
func (_e *Service_Expecter) DeleteTiDBCluster(ctx interface{}, tidbClusterId interface{}) *Service_DeleteTiDBCluster_Call {
	return &Service_DeleteTiDBCluster_Call{Call: _e.mock.On("DeleteTiDBCluster", ctx, tidbClusterId)}
}

func (_c *Service_DeleteTiDBCluster_Call) Run(run func(ctx context.Context, tidbClusterId string)) *Service_DeleteTiDBCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_DeleteTiDBCluster_Call) Return(v *entity.TiDBCluster, err error) *Service_DeleteTiDBCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_DeleteTiDBCluster_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string) (*entity.TiDBCluster, error)) *Service_DeleteTiDBCluster_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTiDBGroup provides a mock function for the type Service
func (_mock *Service) DeleteTiDBGroup(ctx context.Context, tidbClusterId string, tidbGroupId string) (*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, tidbClusterId, tidbGroupId)

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

	var r0 *entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, tidbClusterId, tidbGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, tidbClusterId, tidbGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId, tidbGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteTiDBGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - tidbGroupId string
func (_e *Service_Expecter) DeleteTiDBGroup(ctx interface{}, tidbClusterId interface{}, tidbGroupId interface{}) *Service_DeleteTiDBGroup_Call {
	return &Service_DeleteTiDBGroup_Call{Call: _e.mock.On("DeleteTiDBGroup", ctx, tidbClusterId, tidbGroupId)}
}

func (_c *Service_DeleteTiDBGroup_Call) Run(run func(ctx context.Context, tidbClusterId string, tidbGroupId string)) *Service_DeleteTiDBGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeleteTiDBGroup_Call) Return(tiDBGroup *entity.TiDBGroup, err error) *Service_DeleteTiDBGroup_Call {
	_c.Call.Return(tiDBGroup, err)
	return _c
}

func (_c *Service_DeleteTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, tidbGroupId string) (*entity.TiDBGroup, error)) *Service_DeleteTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTiKVCapacityReservation provides a mock function for the type Service
func (_mock *Service) DeleteTiKVCapacityReservation(ctx context.Context, req *server.DeleteTiKVCapacityReservationInput) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.DeleteTiKVCapacityReservationInput) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteTiKVCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.DeleteTiKVCapacityReservationInput
func (_e *Service_Expecter) DeleteTiKVCapacityReservation(ctx interface{}, req interface{}) *Service_DeleteTiKVCapacityReservation_Call {
	return &Service_DeleteTiKVCapacityReservation_Call{Call: _e.mock.On("DeleteTiKVCapacityReservation", ctx, req)}
}

func (_c *Service_DeleteTiKVCapacityReservation_Call) Run(run func(ctx context.Context, req *server.DeleteTiKVCapacityReservationInput)) *Service_DeleteTiKVCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.DeleteTiKVCapacityReservationInput
		if args[1] != nil {
			arg1 = args[1].(*server.DeleteTiKVCapacityReservationInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_DeleteTiKVCapacityReservation_Call) Return(err error) *Service_DeleteTiKVCapacityReservation_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteTiKVCapacityReservation_Call) RunAndReturn(run func(ctx context.Context, req *server.DeleteTiKVCapacityReservationInput) error) *Service_DeleteTiKVCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTiKVGroup provides a mock function for the type Service
func (_mock *Service) DeleteTiKVGroup(ctx context.Context, sharedPoolId string, tikvGroupId string) error {
	ret := _mock.Called(ctx, sharedPoolId, tikvGroupId)

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

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

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

// DeleteTiKVGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - tikvGroupId string
func (_e *Service_Expecter) DeleteTiKVGroup(ctx interface{}, sharedPoolId interface{}, tikvGroupId interface{}) *Service_DeleteTiKVGroup_Call {
	return &Service_DeleteTiKVGroup_Call{Call: _e.mock.On("DeleteTiKVGroup", ctx, sharedPoolId, tikvGroupId)}
}

func (_c *Service_DeleteTiKVGroup_Call) Run(run func(ctx context.Context, sharedPoolId string, tikvGroupId string)) *Service_DeleteTiKVGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeleteTiKVGroup_Call) Return(err error) *Service_DeleteTiKVGroup_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_DeleteTiKVGroup_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, tikvGroupId string) error) *Service_DeleteTiKVGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeprecateNodeInstanceGroup provides a mock function for the type Service
func (_mock *Service) DeprecateNodeInstanceGroup(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeprecateNodeInstanceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
func (_e *Service_Expecter) DeprecateNodeInstanceGroup(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}) *Service_DeprecateNodeInstanceGroup_Call {
	return &Service_DeprecateNodeInstanceGroup_Call{Call: _e.mock.On("DeprecateNodeInstanceGroup", ctx, nodeSpec, primaryInstance)}
}

func (_c *Service_DeprecateNodeInstanceGroup_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string)) *Service_DeprecateNodeInstanceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_DeprecateNodeInstanceGroup_Call) Return(v *entity.NodeInstanceGroup, err error) *Service_DeprecateNodeInstanceGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_DeprecateNodeInstanceGroup_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error)) *Service_DeprecateNodeInstanceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// EvaluateAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) EvaluateAutoscalePolicy(ctx context.Context, sharedPoolID string, componentType entity.ComponentType, direction entity.AutoscalePolicyDirection, capability entity.AutoscalePolicyCapability, trigger entity.AutoscalePolicyTrigger) (*entity.EvaluateAutoscalePolicyResponse, error) {
	ret := _mock.Called(ctx, sharedPoolID, componentType, direction, capability, trigger)

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

	var r0 *entity.EvaluateAutoscalePolicyResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.ComponentType, entity.AutoscalePolicyDirection, entity.AutoscalePolicyCapability, entity.AutoscalePolicyTrigger) (*entity.EvaluateAutoscalePolicyResponse, error)); ok {
		return returnFunc(ctx, sharedPoolID, componentType, direction, capability, trigger)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.ComponentType, entity.AutoscalePolicyDirection, entity.AutoscalePolicyCapability, entity.AutoscalePolicyTrigger) *entity.EvaluateAutoscalePolicyResponse); ok {
		r0 = returnFunc(ctx, sharedPoolID, componentType, direction, capability, trigger)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.EvaluateAutoscalePolicyResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.ComponentType, entity.AutoscalePolicyDirection, entity.AutoscalePolicyCapability, entity.AutoscalePolicyTrigger) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, componentType, direction, capability, trigger)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// EvaluateAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - componentType entity.ComponentType
//   - direction entity.AutoscalePolicyDirection
//   - capability entity.AutoscalePolicyCapability
//   - trigger entity.AutoscalePolicyTrigger
func (_e *Service_Expecter) EvaluateAutoscalePolicy(ctx interface{}, sharedPoolID interface{}, componentType interface{}, direction interface{}, capability interface{}, trigger interface{}) *Service_EvaluateAutoscalePolicy_Call {
	return &Service_EvaluateAutoscalePolicy_Call{Call: _e.mock.On("EvaluateAutoscalePolicy", ctx, sharedPoolID, componentType, direction, capability, trigger)}
}

func (_c *Service_EvaluateAutoscalePolicy_Call) Run(run func(ctx context.Context, sharedPoolID string, componentType entity.ComponentType, direction entity.AutoscalePolicyDirection, capability entity.AutoscalePolicyCapability, trigger entity.AutoscalePolicyTrigger)) *Service_EvaluateAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.ComponentType
		if args[2] != nil {
			arg2 = args[2].(entity.ComponentType)
		}
		var arg3 entity.AutoscalePolicyDirection
		if args[3] != nil {
			arg3 = args[3].(entity.AutoscalePolicyDirection)
		}
		var arg4 entity.AutoscalePolicyCapability
		if args[4] != nil {
			arg4 = args[4].(entity.AutoscalePolicyCapability)
		}
		var arg5 entity.AutoscalePolicyTrigger
		if args[5] != nil {
			arg5 = args[5].(entity.AutoscalePolicyTrigger)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_EvaluateAutoscalePolicy_Call) Return(v *entity.EvaluateAutoscalePolicyResponse, err error) *Service_EvaluateAutoscalePolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_EvaluateAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, componentType entity.ComponentType, direction entity.AutoscalePolicyDirection, capability entity.AutoscalePolicyCapability, trigger entity.AutoscalePolicyTrigger) (*entity.EvaluateAutoscalePolicyResponse, error)) *Service_EvaluateAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// EvaluateSharedPoolNetworkCapacity provides a mock function for the type Service
func (_mock *Service) EvaluateSharedPoolNetworkCapacity(ctx context.Context, req *entity.EvaluateSharedPoolNetworkCapacityRequest) (*entity.EvaluateSharedPoolNetworkCapacityResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *entity.EvaluateSharedPoolNetworkCapacityResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.EvaluateSharedPoolNetworkCapacityRequest) (*entity.EvaluateSharedPoolNetworkCapacityResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.EvaluateSharedPoolNetworkCapacityRequest) *entity.EvaluateSharedPoolNetworkCapacityResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.EvaluateSharedPoolNetworkCapacityResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.EvaluateSharedPoolNetworkCapacityRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// EvaluateSharedPoolNetworkCapacity is a helper method to define mock.On call
//   - ctx context.Context
//   - req *entity.EvaluateSharedPoolNetworkCapacityRequest
func (_e *Service_Expecter) EvaluateSharedPoolNetworkCapacity(ctx interface{}, req interface{}) *Service_EvaluateSharedPoolNetworkCapacity_Call {
	return &Service_EvaluateSharedPoolNetworkCapacity_Call{Call: _e.mock.On("EvaluateSharedPoolNetworkCapacity", ctx, req)}
}

func (_c *Service_EvaluateSharedPoolNetworkCapacity_Call) Run(run func(ctx context.Context, req *entity.EvaluateSharedPoolNetworkCapacityRequest)) *Service_EvaluateSharedPoolNetworkCapacity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.EvaluateSharedPoolNetworkCapacityRequest
		if args[1] != nil {
			arg1 = args[1].(*entity.EvaluateSharedPoolNetworkCapacityRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_EvaluateSharedPoolNetworkCapacity_Call) Return(v *entity.EvaluateSharedPoolNetworkCapacityResponse, err error) *Service_EvaluateSharedPoolNetworkCapacity_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_EvaluateSharedPoolNetworkCapacity_Call) RunAndReturn(run func(ctx context.Context, req *entity.EvaluateSharedPoolNetworkCapacityRequest) (*entity.EvaluateSharedPoolNetworkCapacityResponse, error)) *Service_EvaluateSharedPoolNetworkCapacity_Call {
	_c.Call.Return(run)
	return _c
}

// ForceUpdateGatewayIdentity provides a mock function for the type Service
func (_mock *Service) ForceUpdateGatewayIdentity(ctx context.Context, tidbClusterId string, gatewayIdentity string) error {
	ret := _mock.Called(ctx, tidbClusterId, gatewayIdentity)

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

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

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

// ForceUpdateGatewayIdentity is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - gatewayIdentity string
func (_e *Service_Expecter) ForceUpdateGatewayIdentity(ctx interface{}, tidbClusterId interface{}, gatewayIdentity interface{}) *Service_ForceUpdateGatewayIdentity_Call {
	return &Service_ForceUpdateGatewayIdentity_Call{Call: _e.mock.On("ForceUpdateGatewayIdentity", ctx, tidbClusterId, gatewayIdentity)}
}

func (_c *Service_ForceUpdateGatewayIdentity_Call) Run(run func(ctx context.Context, tidbClusterId string, gatewayIdentity string)) *Service_ForceUpdateGatewayIdentity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ForceUpdateGatewayIdentity_Call) Return(err error) *Service_ForceUpdateGatewayIdentity_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_ForceUpdateGatewayIdentity_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, gatewayIdentity string) error) *Service_ForceUpdateGatewayIdentity_Call {
	_c.Call.Return(run)
	return _c
}

// GeneratePlanReplayerFileDownloadURL provides a mock function for the type Service
func (_mock *Service) GeneratePlanReplayerFileDownloadURL(ctx context.Context, req *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest) (*cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest) (*cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest) *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GeneratePlanReplayerFileDownloadURL is a helper method to define mock.On call
//   - ctx context.Context
//   - req *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest
func (_e *Service_Expecter) GeneratePlanReplayerFileDownloadURL(ctx interface{}, req interface{}) *Service_GeneratePlanReplayerFileDownloadURL_Call {
	return &Service_GeneratePlanReplayerFileDownloadURL_Call{Call: _e.mock.On("GeneratePlanReplayerFileDownloadURL", ctx, req)}
}

func (_c *Service_GeneratePlanReplayerFileDownloadURL_Call) Run(run func(ctx context.Context, req *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest)) *Service_GeneratePlanReplayerFileDownloadURL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest
		if args[1] != nil {
			arg1 = args[1].(*cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GeneratePlanReplayerFileDownloadURL_Call) Return(generatePlanReplayerFileDownloadURLResponse *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse, err error) *Service_GeneratePlanReplayerFileDownloadURL_Call {
	_c.Call.Return(generatePlanReplayerFileDownloadURLResponse, err)
	return _c
}

func (_c *Service_GeneratePlanReplayerFileDownloadURL_Call) RunAndReturn(run func(ctx context.Context, req *cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLRequest) (*cluster_service_ngv1beta.GeneratePlanReplayerFileDownloadURLResponse, error)) *Service_GeneratePlanReplayerFileDownloadURL_Call {
	_c.Call.Return(run)
	return _c
}

// GetAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) GetAutoscalePolicy(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) (*entity.AutoscalePolicySpecBundle, error) {
	ret := _mock.Called(ctx, scope, subjectID)

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

	var r0 *entity.AutoscalePolicySpecBundle
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) (*entity.AutoscalePolicySpecBundle, error)); ok {
		return returnFunc(ctx, scope, subjectID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) *entity.AutoscalePolicySpecBundle); ok {
		r0 = returnFunc(ctx, scope, subjectID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscalePolicySpecBundle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) error); ok {
		r1 = returnFunc(ctx, scope, subjectID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
func (_e *Service_Expecter) GetAutoscalePolicy(ctx interface{}, scope interface{}, subjectID interface{}) *Service_GetAutoscalePolicy_Call {
	return &Service_GetAutoscalePolicy_Call{Call: _e.mock.On("GetAutoscalePolicy", ctx, scope, subjectID)}
}

func (_c *Service_GetAutoscalePolicy_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string)) *Service_GetAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetAutoscalePolicy_Call) Return(v *entity.AutoscalePolicySpecBundle, err error) *Service_GetAutoscalePolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) (*entity.AutoscalePolicySpecBundle, error)) *Service_GetAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupGcSetting provides a mock function for the type Service
func (_mock *Service) GetBackupGcSetting(ctx context.Context, req *server.GetBackupGcSettingInput) (*server.GetBackupGcSettingOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.GetBackupGcSettingOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetBackupGcSettingInput) (*server.GetBackupGcSettingOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetBackupGcSettingInput) *server.GetBackupGcSettingOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.GetBackupGcSettingOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.GetBackupGcSettingInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetBackupGcSetting is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.GetBackupGcSettingInput
func (_e *Service_Expecter) GetBackupGcSetting(ctx interface{}, req interface{}) *Service_GetBackupGcSetting_Call {
	return &Service_GetBackupGcSetting_Call{Call: _e.mock.On("GetBackupGcSetting", ctx, req)}
}

func (_c *Service_GetBackupGcSetting_Call) Run(run func(ctx context.Context, req *server.GetBackupGcSettingInput)) *Service_GetBackupGcSetting_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.GetBackupGcSettingInput
		if args[1] != nil {
			arg1 = args[1].(*server.GetBackupGcSettingInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetBackupGcSetting_Call) Return(getBackupGcSettingOutput *server.GetBackupGcSettingOutput, err error) *Service_GetBackupGcSetting_Call {
	_c.Call.Return(getBackupGcSettingOutput, err)
	return _c
}

func (_c *Service_GetBackupGcSetting_Call) RunAndReturn(run func(ctx context.Context, req *server.GetBackupGcSettingInput) (*server.GetBackupGcSettingOutput, error)) *Service_GetBackupGcSetting_Call {
	_c.Call.Return(run)
	return _c
}

// GetCassandraProxy provides a mock function for the type Service
func (_mock *Service) GetCassandraProxy(ctx context.Context, req *cluster_service_ngv1beta.GetCassandraProxyRequest) (*cluster_service_ngv1beta.GetCassandraProxyResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *cluster_service_ngv1beta.GetCassandraProxyResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.GetCassandraProxyRequest) (*cluster_service_ngv1beta.GetCassandraProxyResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.GetCassandraProxyRequest) *cluster_service_ngv1beta.GetCassandraProxyResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.GetCassandraProxyResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *cluster_service_ngv1beta.GetCassandraProxyRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetCassandraProxy is a helper method to define mock.On call
//   - ctx context.Context
//   - req *cluster_service_ngv1beta.GetCassandraProxyRequest
func (_e *Service_Expecter) GetCassandraProxy(ctx interface{}, req interface{}) *Service_GetCassandraProxy_Call {
	return &Service_GetCassandraProxy_Call{Call: _e.mock.On("GetCassandraProxy", ctx, req)}
}

func (_c *Service_GetCassandraProxy_Call) Run(run func(ctx context.Context, req *cluster_service_ngv1beta.GetCassandraProxyRequest)) *Service_GetCassandraProxy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *cluster_service_ngv1beta.GetCassandraProxyRequest
		if args[1] != nil {
			arg1 = args[1].(*cluster_service_ngv1beta.GetCassandraProxyRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetCassandraProxy_Call) Return(getCassandraProxyResponse *cluster_service_ngv1beta.GetCassandraProxyResponse, err error) *Service_GetCassandraProxy_Call {
	_c.Call.Return(getCassandraProxyResponse, err)
	return _c
}

func (_c *Service_GetCassandraProxy_Call) RunAndReturn(run func(ctx context.Context, req *cluster_service_ngv1beta.GetCassandraProxyRequest) (*cluster_service_ngv1beta.GetCassandraProxyResponse, error)) *Service_GetCassandraProxy_Call {
	_c.Call.Return(run)
	return _c
}

// GetClassicRestore provides a mock function for the type Service
func (_mock *Service) GetClassicRestore(ctx context.Context, req *server.GetClassicRestoreInput) (*server.GetClassicRestoreOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.GetClassicRestoreOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetClassicRestoreInput) (*server.GetClassicRestoreOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetClassicRestoreInput) *server.GetClassicRestoreOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.GetClassicRestoreOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.GetClassicRestoreInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetClassicRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.GetClassicRestoreInput
func (_e *Service_Expecter) GetClassicRestore(ctx interface{}, req interface{}) *Service_GetClassicRestore_Call {
	return &Service_GetClassicRestore_Call{Call: _e.mock.On("GetClassicRestore", ctx, req)}
}

func (_c *Service_GetClassicRestore_Call) Run(run func(ctx context.Context, req *server.GetClassicRestoreInput)) *Service_GetClassicRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.GetClassicRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*server.GetClassicRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetClassicRestore_Call) Return(getClassicRestoreOutput *server.GetClassicRestoreOutput, err error) *Service_GetClassicRestore_Call {
	_c.Call.Return(getClassicRestoreOutput, err)
	return _c
}

func (_c *Service_GetClassicRestore_Call) RunAndReturn(run func(ctx context.Context, req *server.GetClassicRestoreInput) (*server.GetClassicRestoreOutput, error)) *Service_GetClassicRestore_Call {
	_c.Call.Return(run)
	return _c
}

// GetComponentTemplate provides a mock function for the type Service
func (_mock *Service) GetComponentTemplate(ctx context.Context, componentType entity.ComponentType, version string) (*cluster_service_ngv1beta.GetComponentTemplateResponse, error) {
	ret := _mock.Called(ctx, componentType, version)

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

	var r0 *cluster_service_ngv1beta.GetComponentTemplateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ComponentType, string) (*cluster_service_ngv1beta.GetComponentTemplateResponse, error)); ok {
		return returnFunc(ctx, componentType, version)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ComponentType, string) *cluster_service_ngv1beta.GetComponentTemplateResponse); ok {
		r0 = returnFunc(ctx, componentType, version)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.GetComponentTemplateResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.ComponentType, string) error); ok {
		r1 = returnFunc(ctx, componentType, version)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetComponentTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - componentType entity.ComponentType
//   - version string
func (_e *Service_Expecter) GetComponentTemplate(ctx interface{}, componentType interface{}, version interface{}) *Service_GetComponentTemplate_Call {
	return &Service_GetComponentTemplate_Call{Call: _e.mock.On("GetComponentTemplate", ctx, componentType, version)}
}

func (_c *Service_GetComponentTemplate_Call) Run(run func(ctx context.Context, componentType entity.ComponentType, version string)) *Service_GetComponentTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.ComponentType
		if args[1] != nil {
			arg1 = args[1].(entity.ComponentType)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetComponentTemplate_Call) Return(getComponentTemplateResponse *cluster_service_ngv1beta.GetComponentTemplateResponse, err error) *Service_GetComponentTemplate_Call {
	_c.Call.Return(getComponentTemplateResponse, err)
	return _c
}

func (_c *Service_GetComponentTemplate_Call) RunAndReturn(run func(ctx context.Context, componentType entity.ComponentType, version string) (*cluster_service_ngv1beta.GetComponentTemplateResponse, error)) *Service_GetComponentTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetDMCluster provides a mock function for the type Service
func (_mock *Service) GetDMCluster(ctx context.Context, sharedPoolId string, dmClusterId string) (*entity.DMCluster, error) {
	ret := _mock.Called(ctx, sharedPoolId, dmClusterId)

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

	var r0 *entity.DMCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.DMCluster, error)); ok {
		return returnFunc(ctx, sharedPoolId, dmClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.DMCluster); ok {
		r0 = returnFunc(ctx, sharedPoolId, dmClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DMCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, dmClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetDMCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - dmClusterId string
func (_e *Service_Expecter) GetDMCluster(ctx interface{}, sharedPoolId interface{}, dmClusterId interface{}) *Service_GetDMCluster_Call {
	return &Service_GetDMCluster_Call{Call: _e.mock.On("GetDMCluster", ctx, sharedPoolId, dmClusterId)}
}

func (_c *Service_GetDMCluster_Call) Run(run func(ctx context.Context, sharedPoolId string, dmClusterId string)) *Service_GetDMCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetDMCluster_Call) Return(v *entity.DMCluster, err error) *Service_GetDMCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetDMCluster_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, dmClusterId string) (*entity.DMCluster, error)) *Service_GetDMCluster_Call {
	_c.Call.Return(run)
	return _c
}

// GetEffectiveAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) GetEffectiveAutoscalePolicy(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) (*entity.AutoscalePolicySpecBundle, error) {
	ret := _mock.Called(ctx, scope, subjectID)

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

	var r0 *entity.AutoscalePolicySpecBundle
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) (*entity.AutoscalePolicySpecBundle, error)); ok {
		return returnFunc(ctx, scope, subjectID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) *entity.AutoscalePolicySpecBundle); ok {
		r0 = returnFunc(ctx, scope, subjectID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscalePolicySpecBundle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) error); ok {
		r1 = returnFunc(ctx, scope, subjectID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetEffectiveAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
func (_e *Service_Expecter) GetEffectiveAutoscalePolicy(ctx interface{}, scope interface{}, subjectID interface{}) *Service_GetEffectiveAutoscalePolicy_Call {
	return &Service_GetEffectiveAutoscalePolicy_Call{Call: _e.mock.On("GetEffectiveAutoscalePolicy", ctx, scope, subjectID)}
}

func (_c *Service_GetEffectiveAutoscalePolicy_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string)) *Service_GetEffectiveAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetEffectiveAutoscalePolicy_Call) Return(v *entity.AutoscalePolicySpecBundle, err error) *Service_GetEffectiveAutoscalePolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetEffectiveAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) (*entity.AutoscalePolicySpecBundle, error)) *Service_GetEffectiveAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetExport provides a mock function for the type Service
func (_mock *Service) GetExport(ctx context.Context, clusterId string, exportId string) (*entity.Export, error) {
	ret := _mock.Called(ctx, clusterId, exportId)

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

	var r0 *entity.Export
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.Export, error)); ok {
		return returnFunc(ctx, clusterId, exportId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.Export); ok {
		r0 = returnFunc(ctx, clusterId, exportId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Export)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, clusterId, exportId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *Service_GetExport_Call) Run(run func(ctx context.Context, clusterId string, exportId string)) *Service_GetExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetExport_Call) Return(v *entity.Export, err error) *Service_GetExport_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetExport_Call) RunAndReturn(run func(ctx context.Context, clusterId string, exportId string) (*entity.Export, error)) *Service_GetExport_Call {
	_c.Call.Return(run)
	return _c
}

// GetHPASpec provides a mock function for the type Service
func (_mock *Service) GetHPASpec(ctx context.Context, sharedPoolId string) ([]entity.ComponentHPASpec, error) {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 []entity.ComponentHPASpec
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]entity.ComponentHPASpec, error)); ok {
		return returnFunc(ctx, sharedPoolId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []entity.ComponentHPASpec); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]entity.ComponentHPASpec)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetHPASpec is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *Service_Expecter) GetHPASpec(ctx interface{}, sharedPoolId interface{}) *Service_GetHPASpec_Call {
	return &Service_GetHPASpec_Call{Call: _e.mock.On("GetHPASpec", ctx, sharedPoolId)}
}

func (_c *Service_GetHPASpec_Call) Run(run func(ctx context.Context, sharedPoolId string)) *Service_GetHPASpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetHPASpec_Call) Return(vs []entity.ComponentHPASpec, err error) *Service_GetHPASpec_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_GetHPASpec_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) ([]entity.ComponentHPASpec, error)) *Service_GetHPASpec_Call {
	_c.Call.Return(run)
	return _c
}

// GetImportRoleConfig provides a mock function for the type Service
func (_mock *Service) GetImportRoleConfig(ctx context.Context, tidbClusterId string) (*entity.ImportRoleConfig, error) {
	ret := _mock.Called(ctx, tidbClusterId)

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

	var r0 *entity.ImportRoleConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.ImportRoleConfig, error)); ok {
		return returnFunc(ctx, tidbClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.ImportRoleConfig); ok {
		r0 = returnFunc(ctx, tidbClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ImportRoleConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetImportRoleConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
func (_e *Service_Expecter) GetImportRoleConfig(ctx interface{}, tidbClusterId interface{}) *Service_GetImportRoleConfig_Call {
	return &Service_GetImportRoleConfig_Call{Call: _e.mock.On("GetImportRoleConfig", ctx, tidbClusterId)}
}

func (_c *Service_GetImportRoleConfig_Call) Run(run func(ctx context.Context, tidbClusterId string)) *Service_GetImportRoleConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetImportRoleConfig_Call) Return(v *entity.ImportRoleConfig, err error) *Service_GetImportRoleConfig_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetImportRoleConfig_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string) (*entity.ImportRoleConfig, error)) *Service_GetImportRoleConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetLightweightRestore provides a mock function for the type Service
func (_mock *Service) GetLightweightRestore(ctx context.Context, req *br.GetLightweightRestoreInput) (*br.GetLightweightRestoreOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *br.GetLightweightRestoreOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *br.GetLightweightRestoreInput) (*br.GetLightweightRestoreOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *br.GetLightweightRestoreInput) *br.GetLightweightRestoreOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*br.GetLightweightRestoreOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *br.GetLightweightRestoreInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetLightweightRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *br.GetLightweightRestoreInput
func (_e *Service_Expecter) GetLightweightRestore(ctx interface{}, req interface{}) *Service_GetLightweightRestore_Call {
	return &Service_GetLightweightRestore_Call{Call: _e.mock.On("GetLightweightRestore", ctx, req)}
}

func (_c *Service_GetLightweightRestore_Call) Run(run func(ctx context.Context, req *br.GetLightweightRestoreInput)) *Service_GetLightweightRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *br.GetLightweightRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*br.GetLightweightRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetLightweightRestore_Call) Return(getLightweightRestoreOutput *br.GetLightweightRestoreOutput, err error) *Service_GetLightweightRestore_Call {
	_c.Call.Return(getLightweightRestoreOutput, err)
	return _c
}

func (_c *Service_GetLightweightRestore_Call) RunAndReturn(run func(ctx context.Context, req *br.GetLightweightRestoreInput) (*br.GetLightweightRestoreOutput, error)) *Service_GetLightweightRestore_Call {
	_c.Call.Return(run)
	return _c
}

// GetLightweightRestorePostActions provides a mock function for the type Service
func (_mock *Service) GetLightweightRestorePostActions(ctx context.Context, req *br.GetLightweightRestorePostActionsInput) (*br.GetLightweightRestorePostActionsOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *br.GetLightweightRestorePostActionsOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *br.GetLightweightRestorePostActionsInput) (*br.GetLightweightRestorePostActionsOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *br.GetLightweightRestorePostActionsInput) *br.GetLightweightRestorePostActionsOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*br.GetLightweightRestorePostActionsOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *br.GetLightweightRestorePostActionsInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetLightweightRestorePostActions is a helper method to define mock.On call
//   - ctx context.Context
//   - req *br.GetLightweightRestorePostActionsInput
func (_e *Service_Expecter) GetLightweightRestorePostActions(ctx interface{}, req interface{}) *Service_GetLightweightRestorePostActions_Call {
	return &Service_GetLightweightRestorePostActions_Call{Call: _e.mock.On("GetLightweightRestorePostActions", ctx, req)}
}

func (_c *Service_GetLightweightRestorePostActions_Call) Run(run func(ctx context.Context, req *br.GetLightweightRestorePostActionsInput)) *Service_GetLightweightRestorePostActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *br.GetLightweightRestorePostActionsInput
		if args[1] != nil {
			arg1 = args[1].(*br.GetLightweightRestorePostActionsInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetLightweightRestorePostActions_Call) Return(getLightweightRestorePostActionsOutput *br.GetLightweightRestorePostActionsOutput, err error) *Service_GetLightweightRestorePostActions_Call {
	_c.Call.Return(getLightweightRestorePostActionsOutput, err)
	return _c
}

func (_c *Service_GetLightweightRestorePostActions_Call) RunAndReturn(run func(ctx context.Context, req *br.GetLightweightRestorePostActionsInput) (*br.GetLightweightRestorePostActionsOutput, error)) *Service_GetLightweightRestorePostActions_Call {
	_c.Call.Return(run)
	return _c
}

// GetManualBackup provides a mock function for the type Service
func (_mock *Service) GetManualBackup(ctx context.Context, req *server.GetManualBackupInput) (*server.GetManualBackupOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.GetManualBackupOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetManualBackupInput) (*server.GetManualBackupOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetManualBackupInput) *server.GetManualBackupOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.GetManualBackupOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.GetManualBackupInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetManualBackup is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.GetManualBackupInput
func (_e *Service_Expecter) GetManualBackup(ctx interface{}, req interface{}) *Service_GetManualBackup_Call {
	return &Service_GetManualBackup_Call{Call: _e.mock.On("GetManualBackup", ctx, req)}
}

func (_c *Service_GetManualBackup_Call) Run(run func(ctx context.Context, req *server.GetManualBackupInput)) *Service_GetManualBackup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.GetManualBackupInput
		if args[1] != nil {
			arg1 = args[1].(*server.GetManualBackupInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetManualBackup_Call) Return(getManualBackupOutput *server.GetManualBackupOutput, err error) *Service_GetManualBackup_Call {
	_c.Call.Return(getManualBackupOutput, err)
	return _c
}

func (_c *Service_GetManualBackup_Call) RunAndReturn(run func(ctx context.Context, req *server.GetManualBackupInput) (*server.GetManualBackupOutput, error)) *Service_GetManualBackup_Call {
	_c.Call.Return(run)
	return _c
}

// GetManualBackupRestore provides a mock function for the type Service
func (_mock *Service) GetManualBackupRestore(ctx context.Context, req *server.GetManualBackupRestoreInput) (*server.GetManualBackupRestoreOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.GetManualBackupRestoreOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetManualBackupRestoreInput) (*server.GetManualBackupRestoreOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetManualBackupRestoreInput) *server.GetManualBackupRestoreOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.GetManualBackupRestoreOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.GetManualBackupRestoreInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetManualBackupRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.GetManualBackupRestoreInput
func (_e *Service_Expecter) GetManualBackupRestore(ctx interface{}, req interface{}) *Service_GetManualBackupRestore_Call {
	return &Service_GetManualBackupRestore_Call{Call: _e.mock.On("GetManualBackupRestore", ctx, req)}
}

func (_c *Service_GetManualBackupRestore_Call) Run(run func(ctx context.Context, req *server.GetManualBackupRestoreInput)) *Service_GetManualBackupRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.GetManualBackupRestoreInput
		if args[1] != nil {
			arg1 = args[1].(*server.GetManualBackupRestoreInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetManualBackupRestore_Call) Return(getManualBackupRestoreOutput *server.GetManualBackupRestoreOutput, err error) *Service_GetManualBackupRestore_Call {
	_c.Call.Return(getManualBackupRestoreOutput, err)
	return _c
}

func (_c *Service_GetManualBackupRestore_Call) RunAndReturn(run func(ctx context.Context, req *server.GetManualBackupRestoreInput) (*server.GetManualBackupRestoreOutput, error)) *Service_GetManualBackupRestore_Call {
	_c.Call.Return(run)
	return _c
}

// GetManualBackupRestorePostActions provides a mock function for the type Service
func (_mock *Service) GetManualBackupRestorePostActions(ctx context.Context, req *server.GetManualBackupRestorePostActionsInput) (*server.GetManualBackupRestorePostActionsOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.GetManualBackupRestorePostActionsOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetManualBackupRestorePostActionsInput) (*server.GetManualBackupRestorePostActionsOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetManualBackupRestorePostActionsInput) *server.GetManualBackupRestorePostActionsOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.GetManualBackupRestorePostActionsOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.GetManualBackupRestorePostActionsInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetManualBackupRestorePostActions is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.GetManualBackupRestorePostActionsInput
func (_e *Service_Expecter) GetManualBackupRestorePostActions(ctx interface{}, req interface{}) *Service_GetManualBackupRestorePostActions_Call {
	return &Service_GetManualBackupRestorePostActions_Call{Call: _e.mock.On("GetManualBackupRestorePostActions", ctx, req)}
}

func (_c *Service_GetManualBackupRestorePostActions_Call) Run(run func(ctx context.Context, req *server.GetManualBackupRestorePostActionsInput)) *Service_GetManualBackupRestorePostActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.GetManualBackupRestorePostActionsInput
		if args[1] != nil {
			arg1 = args[1].(*server.GetManualBackupRestorePostActionsInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetManualBackupRestorePostActions_Call) Return(getManualBackupRestorePostActionsOutput *server.GetManualBackupRestorePostActionsOutput, err error) *Service_GetManualBackupRestorePostActions_Call {
	_c.Call.Return(getManualBackupRestorePostActionsOutput, err)
	return _c
}

func (_c *Service_GetManualBackupRestorePostActions_Call) RunAndReturn(run func(ctx context.Context, req *server.GetManualBackupRestorePostActionsInput) (*server.GetManualBackupRestorePostActionsOutput, error)) *Service_GetManualBackupRestorePostActions_Call {
	_c.Call.Return(run)
	return _c
}

// GetPauseResumeOperation provides a mock function for the type Service
func (_mock *Service) GetPauseResumeOperation(ctx context.Context, sharedPoolID string, operationID string) (*entity.PauseResumeOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID)

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

	var r0 *entity.PauseResumeOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.PauseResumeOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.PauseResumeOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PauseResumeOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetPauseResumeOperation is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
func (_e *Service_Expecter) GetPauseResumeOperation(ctx interface{}, sharedPoolID interface{}, operationID interface{}) *Service_GetPauseResumeOperation_Call {
	return &Service_GetPauseResumeOperation_Call{Call: _e.mock.On("GetPauseResumeOperation", ctx, sharedPoolID, operationID)}
}

func (_c *Service_GetPauseResumeOperation_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string)) *Service_GetPauseResumeOperation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetPauseResumeOperation_Call) Return(v *entity.PauseResumeOperation, err error) *Service_GetPauseResumeOperation_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetPauseResumeOperation_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string) (*entity.PauseResumeOperation, error)) *Service_GetPauseResumeOperation_Call {
	_c.Call.Return(run)
	return _c
}

// GetPlacementPolicy provides a mock function for the type Service
func (_mock *Service) GetPlacementPolicy(ctx context.Context, sharedPoolId string, placementPolicyId string) (*entity.PlacementPolicy, error) {
	ret := _mock.Called(ctx, sharedPoolId, placementPolicyId)

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

	var r0 *entity.PlacementPolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.PlacementPolicy, error)); ok {
		return returnFunc(ctx, sharedPoolId, placementPolicyId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.PlacementPolicy); ok {
		r0 = returnFunc(ctx, sharedPoolId, placementPolicyId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PlacementPolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, placementPolicyId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetPlacementPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - placementPolicyId string
func (_e *Service_Expecter) GetPlacementPolicy(ctx interface{}, sharedPoolId interface{}, placementPolicyId interface{}) *Service_GetPlacementPolicy_Call {
	return &Service_GetPlacementPolicy_Call{Call: _e.mock.On("GetPlacementPolicy", ctx, sharedPoolId, placementPolicyId)}
}

func (_c *Service_GetPlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, placementPolicyId string)) *Service_GetPlacementPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetPlacementPolicy_Call) Return(v *entity.PlacementPolicy, err error) *Service_GetPlacementPolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetPlacementPolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, placementPolicyId string) (*entity.PlacementPolicy, error)) *Service_GetPlacementPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateLinkService provides a mock function for the type Service
func (_mock *Service) GetPrivateLinkService(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string) (*entity.PrivateLinkService, error) {
	ret := _mock.Called(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)

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

	var r0 *entity.PrivateLinkService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.PrivateLinkService, error)); ok {
		return returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.PrivateLinkService); ok {
		r0 = returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PrivateLinkService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetPrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - tidbGroupId string
//   - privateLinkServiceId string
func (_e *Service_Expecter) GetPrivateLinkService(ctx interface{}, tidbClusterId interface{}, tidbGroupId interface{}, privateLinkServiceId interface{}) *Service_GetPrivateLinkService_Call {
	return &Service_GetPrivateLinkService_Call{Call: _e.mock.On("GetPrivateLinkService", ctx, tidbClusterId, tidbGroupId, privateLinkServiceId)}
}

func (_c *Service_GetPrivateLinkService_Call) Run(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string)) *Service_GetPrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_GetPrivateLinkService_Call) Return(v *entity.PrivateLinkService, err error) *Service_GetPrivateLinkService_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetPrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string) (*entity.PrivateLinkService, error)) *Service_GetPrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// GetProviderRole provides a mock function for the type Service
func (_mock *Service) GetProviderRole(ctx context.Context, tidbClusterId string) (*entity.ProviderRole, error) {
	ret := _mock.Called(ctx, tidbClusterId)

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

	var r0 *entity.ProviderRole
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.ProviderRole, error)); ok {
		return returnFunc(ctx, tidbClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.ProviderRole); ok {
		r0 = returnFunc(ctx, tidbClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ProviderRole)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProviderRole is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
func (_e *Service_Expecter) GetProviderRole(ctx interface{}, tidbClusterId interface{}) *Service_GetProviderRole_Call {
	return &Service_GetProviderRole_Call{Call: _e.mock.On("GetProviderRole", ctx, tidbClusterId)}
}

func (_c *Service_GetProviderRole_Call) Run(run func(ctx context.Context, tidbClusterId string)) *Service_GetProviderRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetProviderRole_Call) Return(v *entity.ProviderRole, err error) *Service_GetProviderRole_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetProviderRole_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string) (*entity.ProviderRole, error)) *Service_GetProviderRole_Call {
	_c.Call.Return(run)
	return _c
}

// GetResolvedAutoscalePolicyBundle provides a mock function for the type Service
func (_mock *Service) GetResolvedAutoscalePolicyBundle(ctx context.Context, sharedPoolID string, componentType entity.ComponentType) (*entity.ResolvedAutoscalePolicyBundle, error) {
	ret := _mock.Called(ctx, sharedPoolID, componentType)

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

	var r0 *entity.ResolvedAutoscalePolicyBundle
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.ComponentType) (*entity.ResolvedAutoscalePolicyBundle, error)); ok {
		return returnFunc(ctx, sharedPoolID, componentType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.ComponentType) *entity.ResolvedAutoscalePolicyBundle); ok {
		r0 = returnFunc(ctx, sharedPoolID, componentType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ResolvedAutoscalePolicyBundle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.ComponentType) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, componentType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetResolvedAutoscalePolicyBundle is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - componentType entity.ComponentType
func (_e *Service_Expecter) GetResolvedAutoscalePolicyBundle(ctx interface{}, sharedPoolID interface{}, componentType interface{}) *Service_GetResolvedAutoscalePolicyBundle_Call {
	return &Service_GetResolvedAutoscalePolicyBundle_Call{Call: _e.mock.On("GetResolvedAutoscalePolicyBundle", ctx, sharedPoolID, componentType)}
}

func (_c *Service_GetResolvedAutoscalePolicyBundle_Call) Run(run func(ctx context.Context, sharedPoolID string, componentType entity.ComponentType)) *Service_GetResolvedAutoscalePolicyBundle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.ComponentType
		if args[2] != nil {
			arg2 = args[2].(entity.ComponentType)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetResolvedAutoscalePolicyBundle_Call) Return(v *entity.ResolvedAutoscalePolicyBundle, err error) *Service_GetResolvedAutoscalePolicyBundle_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetResolvedAutoscalePolicyBundle_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, componentType entity.ComponentType) (*entity.ResolvedAutoscalePolicyBundle, error)) *Service_GetResolvedAutoscalePolicyBundle_Call {
	_c.Call.Return(run)
	return _c
}

// GetRuConfig provides a mock function for the type Service
func (_mock *Service) GetRuConfig(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfig, error) {
	ret := _mock.Called(ctx, id, scope)

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

	var r0 *entity.RuConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) (*entity.RuConfig, error)); ok {
		return returnFunc(ctx, id, scope)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) *entity.RuConfig); ok {
		r0 = returnFunc(ctx, id, scope)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.RuConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.RuConfigScope) error); ok {
		r1 = returnFunc(ctx, id, scope)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRuConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
func (_e *Service_Expecter) GetRuConfig(ctx interface{}, id interface{}, scope interface{}) *Service_GetRuConfig_Call {
	return &Service_GetRuConfig_Call{Call: _e.mock.On("GetRuConfig", ctx, id, scope)}
}

func (_c *Service_GetRuConfig_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope)) *Service_GetRuConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetRuConfig_Call) Return(ruConfig *entity.RuConfig, err error) *Service_GetRuConfig_Call {
	_c.Call.Return(ruConfig, err)
	return _c
}

func (_c *Service_GetRuConfig_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfig, error)) *Service_GetRuConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetScaleOperation provides a mock function for the type Service
func (_mock *Service) GetScaleOperation(ctx context.Context, sharedPoolID string, scaleOperationID string) (*entity.ScaleOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID, scaleOperationID)

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

	var r0 *entity.ScaleOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.ScaleOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID, scaleOperationID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.ScaleOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID, scaleOperationID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ScaleOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, scaleOperationID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetScaleOperation is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - scaleOperationID string
func (_e *Service_Expecter) GetScaleOperation(ctx interface{}, sharedPoolID interface{}, scaleOperationID interface{}) *Service_GetScaleOperation_Call {
	return &Service_GetScaleOperation_Call{Call: _e.mock.On("GetScaleOperation", ctx, sharedPoolID, scaleOperationID)}
}

func (_c *Service_GetScaleOperation_Call) Run(run func(ctx context.Context, sharedPoolID string, scaleOperationID string)) *Service_GetScaleOperation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetScaleOperation_Call) Return(scaleOperation *entity.ScaleOperation, err error) *Service_GetScaleOperation_Call {
	_c.Call.Return(scaleOperation, err)
	return _c
}

func (_c *Service_GetScaleOperation_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, scaleOperationID string) (*entity.ScaleOperation, error)) *Service_GetScaleOperation_Call {
	_c.Call.Return(run)
	return _c
}

// GetSharedPool provides a mock function for the type Service
func (_mock *Service) GetSharedPool(ctx context.Context, sharedPoolId string) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *Service_Expecter) GetSharedPool(ctx interface{}, sharedPoolId interface{}) *Service_GetSharedPool_Call {
	return &Service_GetSharedPool_Call{Call: _e.mock.On("GetSharedPool", ctx, sharedPoolId)}
}

func (_c *Service_GetSharedPool_Call) Run(run func(ctx context.Context, sharedPoolId string)) *Service_GetSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetSharedPool_Call) Return(sharedPool *entity.SharedPool, err error) *Service_GetSharedPool_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_GetSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) (*entity.SharedPool, error)) *Service_GetSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// GetSharedPoolProvisionConfiguration provides a mock function for the type Service
func (_mock *Service) GetSharedPoolProvisionConfiguration(ctx context.Context) (*entity.SharedPoolProvisionConfiguration, error) {
	ret := _mock.Called(ctx)

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

	var r0 *entity.SharedPoolProvisionConfiguration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.SharedPoolProvisionConfiguration, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.SharedPoolProvisionConfiguration); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPoolProvisionConfiguration)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *Service_GetSharedPoolProvisionConfiguration_Call) Run(run func(ctx context.Context)) *Service_GetSharedPoolProvisionConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Service_GetSharedPoolProvisionConfiguration_Call) Return(v *entity.SharedPoolProvisionConfiguration, err error) *Service_GetSharedPoolProvisionConfiguration_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetSharedPoolProvisionConfiguration_Call) RunAndReturn(run func(ctx context.Context) (*entity.SharedPoolProvisionConfiguration, error)) *Service_GetSharedPoolProvisionConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetSharedPoolScaleConstraints provides a mock function for the type Service
func (_mock *Service) GetSharedPoolScaleConstraints(ctx context.Context, sharedPoolId string) (*entity.GetSharedPoolScaleConstraintsResponse, error) {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 *entity.GetSharedPoolScaleConstraintsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.GetSharedPoolScaleConstraintsResponse, error)); ok {
		return returnFunc(ctx, sharedPoolId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.GetSharedPoolScaleConstraintsResponse); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.GetSharedPoolScaleConstraintsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetSharedPoolScaleConstraints is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *Service_Expecter) GetSharedPoolScaleConstraints(ctx interface{}, sharedPoolId interface{}) *Service_GetSharedPoolScaleConstraints_Call {
	return &Service_GetSharedPoolScaleConstraints_Call{Call: _e.mock.On("GetSharedPoolScaleConstraints", ctx, sharedPoolId)}
}

func (_c *Service_GetSharedPoolScaleConstraints_Call) Run(run func(ctx context.Context, sharedPoolId string)) *Service_GetSharedPoolScaleConstraints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetSharedPoolScaleConstraints_Call) Return(v *entity.GetSharedPoolScaleConstraintsResponse, err error) *Service_GetSharedPoolScaleConstraints_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetSharedPoolScaleConstraints_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) (*entity.GetSharedPoolScaleConstraintsResponse, error)) *Service_GetSharedPoolScaleConstraints_Call {
	_c.Call.Return(run)
	return _c
}

// GetSharedPoolVcpusUsage provides a mock function for the type Service
func (_mock *Service) GetSharedPoolVcpusUsage(ctx context.Context, sharedPoolId string) (*cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse, error) {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 *cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse, error)); ok {
		return returnFunc(ctx, sharedPoolId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetSharedPoolVcpusUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *Service_Expecter) GetSharedPoolVcpusUsage(ctx interface{}, sharedPoolId interface{}) *Service_GetSharedPoolVcpusUsage_Call {
	return &Service_GetSharedPoolVcpusUsage_Call{Call: _e.mock.On("GetSharedPoolVcpusUsage", ctx, sharedPoolId)}
}

func (_c *Service_GetSharedPoolVcpusUsage_Call) Run(run func(ctx context.Context, sharedPoolId string)) *Service_GetSharedPoolVcpusUsage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetSharedPoolVcpusUsage_Call) Return(getSharedPoolVcpusUsageResponse *cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse, err error) *Service_GetSharedPoolVcpusUsage_Call {
	_c.Call.Return(getSharedPoolVcpusUsageResponse, err)
	return _c
}

func (_c *Service_GetSharedPoolVcpusUsage_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) (*cluster_service_ngv1beta.GetSharedPoolVcpusUsageResponse, error)) *Service_GetSharedPoolVcpusUsage_Call {
	_c.Call.Return(run)
	return _c
}

// GetTemplate provides a mock function for the type Service
func (_mock *Service) GetTemplate(ctx context.Context, templateName string, version string) (*cluster_service_ngv1beta.GetTemplateResponse, error) {
	ret := _mock.Called(ctx, templateName, version)

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

	var r0 *cluster_service_ngv1beta.GetTemplateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*cluster_service_ngv1beta.GetTemplateResponse, error)); ok {
		return returnFunc(ctx, templateName, version)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *cluster_service_ngv1beta.GetTemplateResponse); ok {
		r0 = returnFunc(ctx, templateName, version)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.GetTemplateResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, templateName, version)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
//   - version string
func (_e *Service_Expecter) GetTemplate(ctx interface{}, templateName interface{}, version interface{}) *Service_GetTemplate_Call {
	return &Service_GetTemplate_Call{Call: _e.mock.On("GetTemplate", ctx, templateName, version)}
}

func (_c *Service_GetTemplate_Call) Run(run func(ctx context.Context, templateName string, version string)) *Service_GetTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetTemplate_Call) Return(getTemplateResponse *cluster_service_ngv1beta.GetTemplateResponse, err error) *Service_GetTemplate_Call {
	_c.Call.Return(getTemplateResponse, err)
	return _c
}

func (_c *Service_GetTemplate_Call) RunAndReturn(run func(ctx context.Context, templateName string, version string) (*cluster_service_ngv1beta.GetTemplateResponse, error)) *Service_GetTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiDBCluster provides a mock function for the type Service
func (_mock *Service) GetTiDBCluster(ctx context.Context, tidbClusterId string) (*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, tidbClusterId)

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

	var r0 *entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, tidbClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, tidbClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetTiDBCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
func (_e *Service_Expecter) GetTiDBCluster(ctx interface{}, tidbClusterId interface{}) *Service_GetTiDBCluster_Call {
	return &Service_GetTiDBCluster_Call{Call: _e.mock.On("GetTiDBCluster", ctx, tidbClusterId)}
}

func (_c *Service_GetTiDBCluster_Call) Run(run func(ctx context.Context, tidbClusterId string)) *Service_GetTiDBCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetTiDBCluster_Call) Return(v *entity.TiDBCluster, err error) *Service_GetTiDBCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetTiDBCluster_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string) (*entity.TiDBCluster, error)) *Service_GetTiDBCluster_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiDBClusterTiProxyNodeQuota provides a mock function for the type Service
func (_mock *Service) GetTiDBClusterTiProxyNodeQuota(ctx context.Context, tidbClusterId string) (*entity.NodeQuota, error) {
	ret := _mock.Called(ctx, tidbClusterId)

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

	var r0 *entity.NodeQuota
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.NodeQuota, error)); ok {
		return returnFunc(ctx, tidbClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.NodeQuota); ok {
		r0 = returnFunc(ctx, tidbClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeQuota)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetTiDBClusterTiProxyNodeQuota is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
func (_e *Service_Expecter) GetTiDBClusterTiProxyNodeQuota(ctx interface{}, tidbClusterId interface{}) *Service_GetTiDBClusterTiProxyNodeQuota_Call {
	return &Service_GetTiDBClusterTiProxyNodeQuota_Call{Call: _e.mock.On("GetTiDBClusterTiProxyNodeQuota", ctx, tidbClusterId)}
}

func (_c *Service_GetTiDBClusterTiProxyNodeQuota_Call) Run(run func(ctx context.Context, tidbClusterId string)) *Service_GetTiDBClusterTiProxyNodeQuota_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetTiDBClusterTiProxyNodeQuota_Call) Return(v *entity.NodeQuota, err error) *Service_GetTiDBClusterTiProxyNodeQuota_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetTiDBClusterTiProxyNodeQuota_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string) (*entity.NodeQuota, error)) *Service_GetTiDBClusterTiProxyNodeQuota_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiDBGroup provides a mock function for the type Service
func (_mock *Service) GetTiDBGroup(ctx context.Context, tidbClusterId string, tidbGroupId string) (*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, tidbClusterId, tidbGroupId)

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

	var r0 *entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, tidbClusterId, tidbGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, tidbClusterId, tidbGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId, tidbGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetTiDBGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - tidbGroupId string
func (_e *Service_Expecter) GetTiDBGroup(ctx interface{}, tidbClusterId interface{}, tidbGroupId interface{}) *Service_GetTiDBGroup_Call {
	return &Service_GetTiDBGroup_Call{Call: _e.mock.On("GetTiDBGroup", ctx, tidbClusterId, tidbGroupId)}
}

func (_c *Service_GetTiDBGroup_Call) Run(run func(ctx context.Context, tidbClusterId string, tidbGroupId string)) *Service_GetTiDBGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_GetTiDBGroup_Call) Return(tiDBGroup *entity.TiDBGroup, err error) *Service_GetTiDBGroup_Call {
	_c.Call.Return(tiDBGroup, err)
	return _c
}

func (_c *Service_GetTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, tidbGroupId string) (*entity.TiDBGroup, error)) *Service_GetTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiKVCapacityReservation provides a mock function for the type Service
func (_mock *Service) GetTiKVCapacityReservation(ctx context.Context, req *server.GetTiKVCapacityReservationInput) (*entity.TiKVCapacityReservation, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *entity.TiKVCapacityReservation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetTiKVCapacityReservationInput) (*entity.TiKVCapacityReservation, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.GetTiKVCapacityReservationInput) *entity.TiKVCapacityReservation); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiKVCapacityReservation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.GetTiKVCapacityReservationInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetTiKVCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.GetTiKVCapacityReservationInput
func (_e *Service_Expecter) GetTiKVCapacityReservation(ctx interface{}, req interface{}) *Service_GetTiKVCapacityReservation_Call {
	return &Service_GetTiKVCapacityReservation_Call{Call: _e.mock.On("GetTiKVCapacityReservation", ctx, req)}
}

func (_c *Service_GetTiKVCapacityReservation_Call) Run(run func(ctx context.Context, req *server.GetTiKVCapacityReservationInput)) *Service_GetTiKVCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.GetTiKVCapacityReservationInput
		if args[1] != nil {
			arg1 = args[1].(*server.GetTiKVCapacityReservationInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_GetTiKVCapacityReservation_Call) Return(v *entity.TiKVCapacityReservation, err error) *Service_GetTiKVCapacityReservation_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_GetTiKVCapacityReservation_Call) RunAndReturn(run func(ctx context.Context, req *server.GetTiKVCapacityReservationInput) (*entity.TiKVCapacityReservation, error)) *Service_GetTiKVCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// ListAutoscalePolicies provides a mock function for the type Service
func (_mock *Service) ListAutoscalePolicies(ctx context.Context, subjectType entity.AutoscalePolicySubjectType, subjectID string, componentType entity.ComponentType) (*entity.ListAutoscalePoliciesResponse, error) {
	ret := _mock.Called(ctx, subjectType, subjectID, componentType)

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

	var r0 *entity.ListAutoscalePoliciesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.AutoscalePolicySubjectType, string, entity.ComponentType) (*entity.ListAutoscalePoliciesResponse, error)); ok {
		return returnFunc(ctx, subjectType, subjectID, componentType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.AutoscalePolicySubjectType, string, entity.ComponentType) *entity.ListAutoscalePoliciesResponse); ok {
		r0 = returnFunc(ctx, subjectType, subjectID, componentType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ListAutoscalePoliciesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.AutoscalePolicySubjectType, string, entity.ComponentType) error); ok {
		r1 = returnFunc(ctx, subjectType, subjectID, componentType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListAutoscalePolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - subjectType entity.AutoscalePolicySubjectType
//   - subjectID string
//   - componentType entity.ComponentType
func (_e *Service_Expecter) ListAutoscalePolicies(ctx interface{}, subjectType interface{}, subjectID interface{}, componentType interface{}) *Service_ListAutoscalePolicies_Call {
	return &Service_ListAutoscalePolicies_Call{Call: _e.mock.On("ListAutoscalePolicies", ctx, subjectType, subjectID, componentType)}
}

func (_c *Service_ListAutoscalePolicies_Call) Run(run func(ctx context.Context, subjectType entity.AutoscalePolicySubjectType, subjectID string, componentType entity.ComponentType)) *Service_ListAutoscalePolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.AutoscalePolicySubjectType
		if args[1] != nil {
			arg1 = args[1].(entity.AutoscalePolicySubjectType)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.ComponentType
		if args[3] != nil {
			arg3 = args[3].(entity.ComponentType)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_ListAutoscalePolicies_Call) Return(v *entity.ListAutoscalePoliciesResponse, err error) *Service_ListAutoscalePolicies_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_ListAutoscalePolicies_Call) RunAndReturn(run func(ctx context.Context, subjectType entity.AutoscalePolicySubjectType, subjectID string, componentType entity.ComponentType) (*entity.ListAutoscalePoliciesResponse, error)) *Service_ListAutoscalePolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) ListAutoscalePolicy(ctx context.Context, filter repo.AutoscalePolicyBundleFilter, pageSize uint32, pageToken string) ([]*entity.AutoscalePolicySpecBundle, string, error) {
	ret := _mock.Called(ctx, filter, pageSize, pageToken)

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

	var r0 []*entity.AutoscalePolicySpecBundle
	var r1 string
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) ([]*entity.AutoscalePolicySpecBundle, string, error)); ok {
		return returnFunc(ctx, filter, pageSize, pageToken)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) []*entity.AutoscalePolicySpecBundle); ok {
		r0 = returnFunc(ctx, filter, pageSize, pageToken)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.AutoscalePolicySpecBundle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) string); ok {
		r1 = returnFunc(ctx, filter, pageSize, pageToken)
	} else {
		r1 = ret.Get(1).(string)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) error); ok {
		r2 = returnFunc(ctx, filter, pageSize, pageToken)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - filter repo.AutoscalePolicyBundleFilter
//   - pageSize uint32
//   - pageToken string
func (_e *Service_Expecter) ListAutoscalePolicy(ctx interface{}, filter interface{}, pageSize interface{}, pageToken interface{}) *Service_ListAutoscalePolicy_Call {
	return &Service_ListAutoscalePolicy_Call{Call: _e.mock.On("ListAutoscalePolicy", ctx, filter, pageSize, pageToken)}
}

func (_c *Service_ListAutoscalePolicy_Call) Run(run func(ctx context.Context, filter repo.AutoscalePolicyBundleFilter, pageSize uint32, pageToken string)) *Service_ListAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 repo.AutoscalePolicyBundleFilter
		if args[1] != nil {
			arg1 = args[1].(repo.AutoscalePolicyBundleFilter)
		}
		var arg2 uint32
		if args[2] != nil {
			arg2 = args[2].(uint32)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_ListAutoscalePolicy_Call) Return(vs []*entity.AutoscalePolicySpecBundle, s string, err error) *Service_ListAutoscalePolicy_Call {
	_c.Call.Return(vs, s, err)
	return _c
}

func (_c *Service_ListAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, filter repo.AutoscalePolicyBundleFilter, pageSize uint32, pageToken string) ([]*entity.AutoscalePolicySpecBundle, string, error)) *Service_ListAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ListAutoscaleRuntimeGuards provides a mock function for the type Service
func (_mock *Service) ListAutoscaleRuntimeGuards(ctx context.Context, filter repo.AutoscaleRuntimeGuardFilter) (*entity.ListAutoscaleRuntimeGuardsResponse, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 *entity.ListAutoscaleRuntimeGuardsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscaleRuntimeGuardFilter) (*entity.ListAutoscaleRuntimeGuardsResponse, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscaleRuntimeGuardFilter) *entity.ListAutoscaleRuntimeGuardsResponse); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ListAutoscaleRuntimeGuardsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, repo.AutoscaleRuntimeGuardFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListAutoscaleRuntimeGuards is a helper method to define mock.On call
//   - ctx context.Context
//   - filter repo.AutoscaleRuntimeGuardFilter
func (_e *Service_Expecter) ListAutoscaleRuntimeGuards(ctx interface{}, filter interface{}) *Service_ListAutoscaleRuntimeGuards_Call {
	return &Service_ListAutoscaleRuntimeGuards_Call{Call: _e.mock.On("ListAutoscaleRuntimeGuards", ctx, filter)}
}

func (_c *Service_ListAutoscaleRuntimeGuards_Call) Run(run func(ctx context.Context, filter repo.AutoscaleRuntimeGuardFilter)) *Service_ListAutoscaleRuntimeGuards_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 repo.AutoscaleRuntimeGuardFilter
		if args[1] != nil {
			arg1 = args[1].(repo.AutoscaleRuntimeGuardFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListAutoscaleRuntimeGuards_Call) Return(v *entity.ListAutoscaleRuntimeGuardsResponse, err error) *Service_ListAutoscaleRuntimeGuards_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_ListAutoscaleRuntimeGuards_Call) RunAndReturn(run func(ctx context.Context, filter repo.AutoscaleRuntimeGuardFilter) (*entity.ListAutoscaleRuntimeGuardsResponse, error)) *Service_ListAutoscaleRuntimeGuards_Call {
	_c.Call.Return(run)
	return _c
}

// ListComponentTemplateVersions provides a mock function for the type Service
func (_mock *Service) ListComponentTemplateVersions(ctx context.Context, componentType entity.ComponentType) (*cluster_service_ngv1beta.ListComponentTemplateVersionsResponse, error) {
	ret := _mock.Called(ctx, componentType)

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

	var r0 *cluster_service_ngv1beta.ListComponentTemplateVersionsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ComponentType) (*cluster_service_ngv1beta.ListComponentTemplateVersionsResponse, error)); ok {
		return returnFunc(ctx, componentType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ComponentType) *cluster_service_ngv1beta.ListComponentTemplateVersionsResponse); ok {
		r0 = returnFunc(ctx, componentType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.ListComponentTemplateVersionsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.ComponentType) error); ok {
		r1 = returnFunc(ctx, componentType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListComponentTemplateVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - componentType entity.ComponentType
func (_e *Service_Expecter) ListComponentTemplateVersions(ctx interface{}, componentType interface{}) *Service_ListComponentTemplateVersions_Call {
	return &Service_ListComponentTemplateVersions_Call{Call: _e.mock.On("ListComponentTemplateVersions", ctx, componentType)}
}

func (_c *Service_ListComponentTemplateVersions_Call) Run(run func(ctx context.Context, componentType entity.ComponentType)) *Service_ListComponentTemplateVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.ComponentType
		if args[1] != nil {
			arg1 = args[1].(entity.ComponentType)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListComponentTemplateVersions_Call) Return(listComponentTemplateVersionsResponse *cluster_service_ngv1beta.ListComponentTemplateVersionsResponse, err error) *Service_ListComponentTemplateVersions_Call {
	_c.Call.Return(listComponentTemplateVersionsResponse, err)
	return _c
}

func (_c *Service_ListComponentTemplateVersions_Call) RunAndReturn(run func(ctx context.Context, componentType entity.ComponentType) (*cluster_service_ngv1beta.ListComponentTemplateVersionsResponse, error)) *Service_ListComponentTemplateVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListComponentTemplates provides a mock function for the type Service
func (_mock *Service) ListComponentTemplates(ctx context.Context) (*cluster_service_ngv1beta.ListComponentTemplatesResponse, error) {
	ret := _mock.Called(ctx)

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

	var r0 *cluster_service_ngv1beta.ListComponentTemplatesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*cluster_service_ngv1beta.ListComponentTemplatesResponse, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *cluster_service_ngv1beta.ListComponentTemplatesResponse); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.ListComponentTemplatesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *Service_ListComponentTemplates_Call) Run(run func(ctx context.Context)) *Service_ListComponentTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Service_ListComponentTemplates_Call) Return(listComponentTemplatesResponse *cluster_service_ngv1beta.ListComponentTemplatesResponse, err error) *Service_ListComponentTemplates_Call {
	_c.Call.Return(listComponentTemplatesResponse, err)
	return _c
}

func (_c *Service_ListComponentTemplates_Call) RunAndReturn(run func(ctx context.Context) (*cluster_service_ngv1beta.ListComponentTemplatesResponse, error)) *Service_ListComponentTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// ListDMClusters provides a mock function for the type Service
func (_mock *Service) ListDMClusters(ctx context.Context, sharedPoolId string) ([]*entity.DMCluster, error) {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 []*entity.DMCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DMCluster, error)); ok {
		return returnFunc(ctx, sharedPoolId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DMCluster); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DMCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListDMClusters is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *Service_Expecter) ListDMClusters(ctx interface{}, sharedPoolId interface{}) *Service_ListDMClusters_Call {
	return &Service_ListDMClusters_Call{Call: _e.mock.On("ListDMClusters", ctx, sharedPoolId)}
}

func (_c *Service_ListDMClusters_Call) Run(run func(ctx context.Context, sharedPoolId string)) *Service_ListDMClusters_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListDMClusters_Call) Return(vs []*entity.DMCluster, err error) *Service_ListDMClusters_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ListDMClusters_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) ([]*entity.DMCluster, error)) *Service_ListDMClusters_Call {
	_c.Call.Return(run)
	return _c
}

// ListDataplaneNodeInstanceGroups provides a mock function for the type Service
func (_mock *Service) ListDataplaneNodeInstanceGroups(ctx context.Context, dataplaneName string) ([]*entity.DataplaneNodeInstanceGroup, error) {
	ret := _mock.Called(ctx, dataplaneName)

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

	var r0 []*entity.DataplaneNodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DataplaneNodeInstanceGroup, error)); ok {
		return returnFunc(ctx, dataplaneName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DataplaneNodeInstanceGroup); ok {
		r0 = returnFunc(ctx, dataplaneName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DataplaneNodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListDataplaneNodeInstanceGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
func (_e *Service_Expecter) ListDataplaneNodeInstanceGroups(ctx interface{}, dataplaneName interface{}) *Service_ListDataplaneNodeInstanceGroups_Call {
	return &Service_ListDataplaneNodeInstanceGroups_Call{Call: _e.mock.On("ListDataplaneNodeInstanceGroups", ctx, dataplaneName)}
}

func (_c *Service_ListDataplaneNodeInstanceGroups_Call) Run(run func(ctx context.Context, dataplaneName string)) *Service_ListDataplaneNodeInstanceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListDataplaneNodeInstanceGroups_Call) Return(vs []*entity.DataplaneNodeInstanceGroup, err error) *Service_ListDataplaneNodeInstanceGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ListDataplaneNodeInstanceGroups_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string) ([]*entity.DataplaneNodeInstanceGroup, error)) *Service_ListDataplaneNodeInstanceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// ListExports provides a mock function for the type Service
func (_mock *Service) ListExports(ctx context.Context, clusterId string) ([]*entity.Export, error) {
	ret := _mock.Called(ctx, clusterId)

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

	var r0 []*entity.Export
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.Export, error)); ok {
		return returnFunc(ctx, clusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.Export); ok {
		r0 = returnFunc(ctx, clusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.Export)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, clusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *Service_ListExports_Call) Run(run func(ctx context.Context, clusterId string)) *Service_ListExports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListExports_Call) Return(vs []*entity.Export, err error) *Service_ListExports_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ListExports_Call) RunAndReturn(run func(ctx context.Context, clusterId string) ([]*entity.Export, error)) *Service_ListExports_Call {
	_c.Call.Return(run)
	return _c
}

// ListLightweightBackups provides a mock function for the type Service
func (_mock *Service) ListLightweightBackups(ctx context.Context, req *server.ListLightweightBackupsInput) (*server.ListLightweightBackupsOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.ListLightweightBackupsOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.ListLightweightBackupsInput) (*server.ListLightweightBackupsOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.ListLightweightBackupsInput) *server.ListLightweightBackupsOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.ListLightweightBackupsOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.ListLightweightBackupsInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListLightweightBackups is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.ListLightweightBackupsInput
func (_e *Service_Expecter) ListLightweightBackups(ctx interface{}, req interface{}) *Service_ListLightweightBackups_Call {
	return &Service_ListLightweightBackups_Call{Call: _e.mock.On("ListLightweightBackups", ctx, req)}
}

func (_c *Service_ListLightweightBackups_Call) Run(run func(ctx context.Context, req *server.ListLightweightBackupsInput)) *Service_ListLightweightBackups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.ListLightweightBackupsInput
		if args[1] != nil {
			arg1 = args[1].(*server.ListLightweightBackupsInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListLightweightBackups_Call) Return(listLightweightBackupsOutput *server.ListLightweightBackupsOutput, err error) *Service_ListLightweightBackups_Call {
	_c.Call.Return(listLightweightBackupsOutput, err)
	return _c
}

func (_c *Service_ListLightweightBackups_Call) RunAndReturn(run func(ctx context.Context, req *server.ListLightweightBackupsInput) (*server.ListLightweightBackupsOutput, error)) *Service_ListLightweightBackups_Call {
	_c.Call.Return(run)
	return _c
}

// ListNodeInstanceGroups provides a mock function for the type Service
func (_mock *Service) ListNodeInstanceGroups(ctx context.Context, nodeSpec string) ([]*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec)

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

	var r0 []*entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListNodeInstanceGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
func (_e *Service_Expecter) ListNodeInstanceGroups(ctx interface{}, nodeSpec interface{}) *Service_ListNodeInstanceGroups_Call {
	return &Service_ListNodeInstanceGroups_Call{Call: _e.mock.On("ListNodeInstanceGroups", ctx, nodeSpec)}
}

func (_c *Service_ListNodeInstanceGroups_Call) Run(run func(ctx context.Context, nodeSpec string)) *Service_ListNodeInstanceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListNodeInstanceGroups_Call) Return(vs []*entity.NodeInstanceGroup, err error) *Service_ListNodeInstanceGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ListNodeInstanceGroups_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string) ([]*entity.NodeInstanceGroup, error)) *Service_ListNodeInstanceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// ListNodeSpecs provides a mock function for the type Service
func (_mock *Service) ListNodeSpecs(ctx context.Context, tenantID string, componentType entity.ComponentType) (*entity.ListNodeSpecsResponse, error) {
	ret := _mock.Called(ctx, tenantID, componentType)

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

	var r0 *entity.ListNodeSpecsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.ComponentType) (*entity.ListNodeSpecsResponse, error)); ok {
		return returnFunc(ctx, tenantID, componentType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.ComponentType) *entity.ListNodeSpecsResponse); ok {
		r0 = returnFunc(ctx, tenantID, componentType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ListNodeSpecsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.ComponentType) error); ok {
		r1 = returnFunc(ctx, tenantID, componentType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListNodeSpecs is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantID string
//   - componentType entity.ComponentType
func (_e *Service_Expecter) ListNodeSpecs(ctx interface{}, tenantID interface{}, componentType interface{}) *Service_ListNodeSpecs_Call {
	return &Service_ListNodeSpecs_Call{Call: _e.mock.On("ListNodeSpecs", ctx, tenantID, componentType)}
}

func (_c *Service_ListNodeSpecs_Call) Run(run func(ctx context.Context, tenantID string, componentType entity.ComponentType)) *Service_ListNodeSpecs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.ComponentType
		if args[2] != nil {
			arg2 = args[2].(entity.ComponentType)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ListNodeSpecs_Call) Return(v *entity.ListNodeSpecsResponse, err error) *Service_ListNodeSpecs_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_ListNodeSpecs_Call) RunAndReturn(run func(ctx context.Context, tenantID string, componentType entity.ComponentType) (*entity.ListNodeSpecsResponse, error)) *Service_ListNodeSpecs_Call {
	_c.Call.Return(run)
	return _c
}

// ListPlacementPolicies provides a mock function for the type Service
func (_mock *Service) ListPlacementPolicies(ctx context.Context, sharedPoolId string, tikvGroupId string) ([]*entity.PlacementPolicy, error) {
	ret := _mock.Called(ctx, sharedPoolId, tikvGroupId)

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

	var r0 []*entity.PlacementPolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]*entity.PlacementPolicy, error)); ok {
		return returnFunc(ctx, sharedPoolId, tikvGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []*entity.PlacementPolicy); ok {
		r0 = returnFunc(ctx, sharedPoolId, tikvGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.PlacementPolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, tikvGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListPlacementPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - tikvGroupId string
func (_e *Service_Expecter) ListPlacementPolicies(ctx interface{}, sharedPoolId interface{}, tikvGroupId interface{}) *Service_ListPlacementPolicies_Call {
	return &Service_ListPlacementPolicies_Call{Call: _e.mock.On("ListPlacementPolicies", ctx, sharedPoolId, tikvGroupId)}
}

func (_c *Service_ListPlacementPolicies_Call) Run(run func(ctx context.Context, sharedPoolId string, tikvGroupId string)) *Service_ListPlacementPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ListPlacementPolicies_Call) Return(vs []*entity.PlacementPolicy, err error) *Service_ListPlacementPolicies_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ListPlacementPolicies_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, tikvGroupId string) ([]*entity.PlacementPolicy, error)) *Service_ListPlacementPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListPlanReplayerFiles provides a mock function for the type Service
func (_mock *Service) ListPlanReplayerFiles(ctx context.Context, req *cluster_service_ngv1beta.ListPlanReplayerFilesRequest) (*cluster_service_ngv1beta.ListPlanReplayerFilesResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *cluster_service_ngv1beta.ListPlanReplayerFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.ListPlanReplayerFilesRequest) (*cluster_service_ngv1beta.ListPlanReplayerFilesResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.ListPlanReplayerFilesRequest) *cluster_service_ngv1beta.ListPlanReplayerFilesResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.ListPlanReplayerFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *cluster_service_ngv1beta.ListPlanReplayerFilesRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListPlanReplayerFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - req *cluster_service_ngv1beta.ListPlanReplayerFilesRequest
func (_e *Service_Expecter) ListPlanReplayerFiles(ctx interface{}, req interface{}) *Service_ListPlanReplayerFiles_Call {
	return &Service_ListPlanReplayerFiles_Call{Call: _e.mock.On("ListPlanReplayerFiles", ctx, req)}
}

func (_c *Service_ListPlanReplayerFiles_Call) Run(run func(ctx context.Context, req *cluster_service_ngv1beta.ListPlanReplayerFilesRequest)) *Service_ListPlanReplayerFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *cluster_service_ngv1beta.ListPlanReplayerFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*cluster_service_ngv1beta.ListPlanReplayerFilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListPlanReplayerFiles_Call) Return(listPlanReplayerFilesResponse *cluster_service_ngv1beta.ListPlanReplayerFilesResponse, err error) *Service_ListPlanReplayerFiles_Call {
	_c.Call.Return(listPlanReplayerFilesResponse, err)
	return _c
}

func (_c *Service_ListPlanReplayerFiles_Call) RunAndReturn(run func(ctx context.Context, req *cluster_service_ngv1beta.ListPlanReplayerFilesRequest) (*cluster_service_ngv1beta.ListPlanReplayerFilesResponse, error)) *Service_ListPlanReplayerFiles_Call {
	_c.Call.Return(run)
	return _c
}

// ListSharedPools provides a mock function for the type Service
func (_mock *Service) ListSharedPools(ctx context.Context, sharedPoolIds []string, dataplaneNames []string) ([]*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolIds, dataplaneNames)

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

	var r0 []*entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, []string) ([]*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolIds, dataplaneNames)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, []string) []*entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolIds, dataplaneNames)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, []string) error); ok {
		r1 = returnFunc(ctx, sharedPoolIds, dataplaneNames)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListSharedPools is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolIds []string
//   - dataplaneNames []string
func (_e *Service_Expecter) ListSharedPools(ctx interface{}, sharedPoolIds interface{}, dataplaneNames interface{}) *Service_ListSharedPools_Call {
	return &Service_ListSharedPools_Call{Call: _e.mock.On("ListSharedPools", ctx, sharedPoolIds, dataplaneNames)}
}

func (_c *Service_ListSharedPools_Call) Run(run func(ctx context.Context, sharedPoolIds []string, dataplaneNames []string)) *Service_ListSharedPools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ListSharedPools_Call) Return(sharedPools []*entity.SharedPool, err error) *Service_ListSharedPools_Call {
	_c.Call.Return(sharedPools, err)
	return _c
}

func (_c *Service_ListSharedPools_Call) RunAndReturn(run func(ctx context.Context, sharedPoolIds []string, dataplaneNames []string) ([]*entity.SharedPool, error)) *Service_ListSharedPools_Call {
	_c.Call.Return(run)
	return _c
}

// ListTemplateVersions provides a mock function for the type Service
func (_mock *Service) ListTemplateVersions(ctx context.Context, templateName string) (*cluster_service_ngv1beta.ListTemplateVersionsResponse, error) {
	ret := _mock.Called(ctx, templateName)

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

	var r0 *cluster_service_ngv1beta.ListTemplateVersionsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*cluster_service_ngv1beta.ListTemplateVersionsResponse, error)); ok {
		return returnFunc(ctx, templateName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *cluster_service_ngv1beta.ListTemplateVersionsResponse); ok {
		r0 = returnFunc(ctx, templateName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.ListTemplateVersionsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, templateName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListTemplateVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
func (_e *Service_Expecter) ListTemplateVersions(ctx interface{}, templateName interface{}) *Service_ListTemplateVersions_Call {
	return &Service_ListTemplateVersions_Call{Call: _e.mock.On("ListTemplateVersions", ctx, templateName)}
}

func (_c *Service_ListTemplateVersions_Call) Run(run func(ctx context.Context, templateName string)) *Service_ListTemplateVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListTemplateVersions_Call) Return(listTemplateVersionsResponse *cluster_service_ngv1beta.ListTemplateVersionsResponse, err error) *Service_ListTemplateVersions_Call {
	_c.Call.Return(listTemplateVersionsResponse, err)
	return _c
}

func (_c *Service_ListTemplateVersions_Call) RunAndReturn(run func(ctx context.Context, templateName string) (*cluster_service_ngv1beta.ListTemplateVersionsResponse, error)) *Service_ListTemplateVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListTemplates provides a mock function for the type Service
func (_mock *Service) ListTemplates(ctx context.Context) (*cluster_service_ngv1beta.ListTemplatesResponse, error) {
	ret := _mock.Called(ctx)

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

	var r0 *cluster_service_ngv1beta.ListTemplatesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*cluster_service_ngv1beta.ListTemplatesResponse, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *cluster_service_ngv1beta.ListTemplatesResponse); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.ListTemplatesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *Service_ListTemplates_Call) Run(run func(ctx context.Context)) *Service_ListTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Service_ListTemplates_Call) Return(listTemplatesResponse *cluster_service_ngv1beta.ListTemplatesResponse, err error) *Service_ListTemplates_Call {
	_c.Call.Return(listTemplatesResponse, err)
	return _c
}

func (_c *Service_ListTemplates_Call) RunAndReturn(run func(ctx context.Context) (*cluster_service_ngv1beta.ListTemplatesResponse, error)) *Service_ListTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// ListTiDBClusters provides a mock function for the type Service
func (_mock *Service) ListTiDBClusters(ctx context.Context, sharedPoolId string, tenantId string) ([]*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, sharedPoolId, tenantId)

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

	var r0 []*entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, sharedPoolId, tenantId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []*entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, sharedPoolId, tenantId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, tenantId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListTiDBClusters is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - tenantId string
func (_e *Service_Expecter) ListTiDBClusters(ctx interface{}, sharedPoolId interface{}, tenantId interface{}) *Service_ListTiDBClusters_Call {
	return &Service_ListTiDBClusters_Call{Call: _e.mock.On("ListTiDBClusters", ctx, sharedPoolId, tenantId)}
}

func (_c *Service_ListTiDBClusters_Call) Run(run func(ctx context.Context, sharedPoolId string, tenantId string)) *Service_ListTiDBClusters_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ListTiDBClusters_Call) Return(vs []*entity.TiDBCluster, err error) *Service_ListTiDBClusters_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_ListTiDBClusters_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, tenantId string) ([]*entity.TiDBCluster, error)) *Service_ListTiDBClusters_Call {
	_c.Call.Return(run)
	return _c
}

// ListTiDBGroups provides a mock function for the type Service
func (_mock *Service) ListTiDBGroups(ctx context.Context, tidbClusterId string) ([]*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, tidbClusterId)

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

	var r0 []*entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, tidbClusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, tidbClusterId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tidbClusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListTiDBGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
func (_e *Service_Expecter) ListTiDBGroups(ctx interface{}, tidbClusterId interface{}) *Service_ListTiDBGroups_Call {
	return &Service_ListTiDBGroups_Call{Call: _e.mock.On("ListTiDBGroups", ctx, tidbClusterId)}
}

func (_c *Service_ListTiDBGroups_Call) Run(run func(ctx context.Context, tidbClusterId string)) *Service_ListTiDBGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListTiDBGroups_Call) Return(tiDBGroups []*entity.TiDBGroup, err error) *Service_ListTiDBGroups_Call {
	_c.Call.Return(tiDBGroups, err)
	return _c
}

func (_c *Service_ListTiDBGroups_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string) ([]*entity.TiDBGroup, error)) *Service_ListTiDBGroups_Call {
	_c.Call.Return(run)
	return _c
}

// PatchAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) PatchAutoscalePolicy(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, applyToAllSharedPools *wrapperspb.BoolValue, requestID string) (*entity.AutoscalePolicyResponse, error) {
	ret := _mock.Called(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)

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

	var r0 *entity.AutoscalePolicyResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, *wrapperspb.BoolValue, string) (*entity.AutoscalePolicyResponse, error)); ok {
		return returnFunc(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, *wrapperspb.BoolValue, string) *entity.AutoscalePolicyResponse); ok {
		r0 = returnFunc(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscalePolicyResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, *wrapperspb.BoolValue, string) error); ok {
		r1 = returnFunc(ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PatchAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
//   - specs []*entity.AutoscalePolicySpec
//   - applyToAllSharedPools *wrapperspb.BoolValue
//   - requestID string
func (_e *Service_Expecter) PatchAutoscalePolicy(ctx interface{}, scope interface{}, subjectID interface{}, specs interface{}, applyToAllSharedPools interface{}, requestID interface{}) *Service_PatchAutoscalePolicy_Call {
	return &Service_PatchAutoscalePolicy_Call{Call: _e.mock.On("PatchAutoscalePolicy", ctx, scope, subjectID, specs, applyToAllSharedPools, requestID)}
}

func (_c *Service_PatchAutoscalePolicy_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, applyToAllSharedPools *wrapperspb.BoolValue, requestID string)) *Service_PatchAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []*entity.AutoscalePolicySpec
		if args[3] != nil {
			arg3 = args[3].([]*entity.AutoscalePolicySpec)
		}
		var arg4 *wrapperspb.BoolValue
		if args[4] != nil {
			arg4 = args[4].(*wrapperspb.BoolValue)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_PatchAutoscalePolicy_Call) Return(v *entity.AutoscalePolicyResponse, err error) *Service_PatchAutoscalePolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_PatchAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, applyToAllSharedPools *wrapperspb.BoolValue, requestID string) (*entity.AutoscalePolicyResponse, error)) *Service_PatchAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// PauseSharedPool provides a mock function for the type Service
func (_mock *Service) PauseSharedPool(ctx context.Context, sharedPoolID string, operationID string) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PauseSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
func (_e *Service_Expecter) PauseSharedPool(ctx interface{}, sharedPoolID interface{}, operationID interface{}) *Service_PauseSharedPool_Call {
	return &Service_PauseSharedPool_Call{Call: _e.mock.On("PauseSharedPool", ctx, sharedPoolID, operationID)}
}

func (_c *Service_PauseSharedPool_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string)) *Service_PauseSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_PauseSharedPool_Call) Return(sharedPool *entity.SharedPool, err error) *Service_PauseSharedPool_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_PauseSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string) (*entity.SharedPool, error)) *Service_PauseSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// PreviewAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) PreviewAutoscalePolicy(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, operation cluster_service_ngv1beta.PreviewOperationType, applyToAllSharedPools *wrapperspb.BoolValue) ([]*entity.AutoscalePolicyPreviewTarget, error) {
	ret := _mock.Called(ctx, scope, subjectID, specs, operation, applyToAllSharedPools)

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

	var r0 []*entity.AutoscalePolicyPreviewTarget
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, cluster_service_ngv1beta.PreviewOperationType, *wrapperspb.BoolValue) ([]*entity.AutoscalePolicyPreviewTarget, error)); ok {
		return returnFunc(ctx, scope, subjectID, specs, operation, applyToAllSharedPools)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, cluster_service_ngv1beta.PreviewOperationType, *wrapperspb.BoolValue) []*entity.AutoscalePolicyPreviewTarget); ok {
		r0 = returnFunc(ctx, scope, subjectID, specs, operation, applyToAllSharedPools)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.AutoscalePolicyPreviewTarget)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, []*entity.AutoscalePolicySpec, cluster_service_ngv1beta.PreviewOperationType, *wrapperspb.BoolValue) error); ok {
		r1 = returnFunc(ctx, scope, subjectID, specs, operation, applyToAllSharedPools)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PreviewAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
//   - specs []*entity.AutoscalePolicySpec
//   - operation cluster_service_ngv1beta.PreviewOperationType
//   - applyToAllSharedPools *wrapperspb.BoolValue
func (_e *Service_Expecter) PreviewAutoscalePolicy(ctx interface{}, scope interface{}, subjectID interface{}, specs interface{}, operation interface{}, applyToAllSharedPools interface{}) *Service_PreviewAutoscalePolicy_Call {
	return &Service_PreviewAutoscalePolicy_Call{Call: _e.mock.On("PreviewAutoscalePolicy", ctx, scope, subjectID, specs, operation, applyToAllSharedPools)}
}

func (_c *Service_PreviewAutoscalePolicy_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, operation cluster_service_ngv1beta.PreviewOperationType, applyToAllSharedPools *wrapperspb.BoolValue)) *Service_PreviewAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []*entity.AutoscalePolicySpec
		if args[3] != nil {
			arg3 = args[3].([]*entity.AutoscalePolicySpec)
		}
		var arg4 cluster_service_ngv1beta.PreviewOperationType
		if args[4] != nil {
			arg4 = args[4].(cluster_service_ngv1beta.PreviewOperationType)
		}
		var arg5 *wrapperspb.BoolValue
		if args[5] != nil {
			arg5 = args[5].(*wrapperspb.BoolValue)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_PreviewAutoscalePolicy_Call) Return(vs []*entity.AutoscalePolicyPreviewTarget, err error) *Service_PreviewAutoscalePolicy_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *Service_PreviewAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, specs []*entity.AutoscalePolicySpec, operation cluster_service_ngv1beta.PreviewOperationType, applyToAllSharedPools *wrapperspb.BoolValue) ([]*entity.AutoscalePolicyPreviewTarget, error)) *Service_PreviewAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ReportAutoBackupMetering provides a mock function for the type Service
func (_mock *Service) ReportAutoBackupMetering(ctx context.Context, req *cluster_service_ngv1beta.ReportAutoBackupMeteringRequest) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.ReportAutoBackupMeteringRequest) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ReportAutoBackupMetering is a helper method to define mock.On call
//   - ctx context.Context
//   - req *cluster_service_ngv1beta.ReportAutoBackupMeteringRequest
func (_e *Service_Expecter) ReportAutoBackupMetering(ctx interface{}, req interface{}) *Service_ReportAutoBackupMetering_Call {
	return &Service_ReportAutoBackupMetering_Call{Call: _e.mock.On("ReportAutoBackupMetering", ctx, req)}
}

func (_c *Service_ReportAutoBackupMetering_Call) Run(run func(ctx context.Context, req *cluster_service_ngv1beta.ReportAutoBackupMeteringRequest)) *Service_ReportAutoBackupMetering_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *cluster_service_ngv1beta.ReportAutoBackupMeteringRequest
		if args[1] != nil {
			arg1 = args[1].(*cluster_service_ngv1beta.ReportAutoBackupMeteringRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ReportAutoBackupMetering_Call) Return(err error) *Service_ReportAutoBackupMetering_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_ReportAutoBackupMetering_Call) RunAndReturn(run func(ctx context.Context, req *cluster_service_ngv1beta.ReportAutoBackupMeteringRequest) error) *Service_ReportAutoBackupMetering_Call {
	_c.Call.Return(run)
	return _c
}

// ResumeSharedPool provides a mock function for the type Service
func (_mock *Service) ResumeSharedPool(ctx context.Context, sharedPoolID string, operationID string) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ResumeSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
func (_e *Service_Expecter) ResumeSharedPool(ctx interface{}, sharedPoolID interface{}, operationID interface{}) *Service_ResumeSharedPool_Call {
	return &Service_ResumeSharedPool_Call{Call: _e.mock.On("ResumeSharedPool", ctx, sharedPoolID, operationID)}
}

func (_c *Service_ResumeSharedPool_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string)) *Service_ResumeSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ResumeSharedPool_Call) Return(sharedPool *entity.SharedPool, err error) *Service_ResumeSharedPool_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_ResumeSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string) (*entity.SharedPool, error)) *Service_ResumeSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// ScaleDMCluster provides a mock function for the type Service
func (_mock *Service) ScaleDMCluster(ctx context.Context, sharedPoolId string, dmClusterId string, masterNodeQuota *entity.NodeQuota, workerNodeQuota *entity.NodeQuota, force bool) (*entity.DMCluster, error) {
	ret := _mock.Called(ctx, sharedPoolId, dmClusterId, masterNodeQuota, workerNodeQuota, force)

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

	var r0 *entity.DMCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.NodeQuota, *entity.NodeQuota, bool) (*entity.DMCluster, error)); ok {
		return returnFunc(ctx, sharedPoolId, dmClusterId, masterNodeQuota, workerNodeQuota, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.NodeQuota, *entity.NodeQuota, bool) *entity.DMCluster); ok {
		r0 = returnFunc(ctx, sharedPoolId, dmClusterId, masterNodeQuota, workerNodeQuota, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DMCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *entity.NodeQuota, *entity.NodeQuota, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, dmClusterId, masterNodeQuota, workerNodeQuota, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ScaleDMCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - dmClusterId string
//   - masterNodeQuota *entity.NodeQuota
//   - workerNodeQuota *entity.NodeQuota
//   - force bool
func (_e *Service_Expecter) ScaleDMCluster(ctx interface{}, sharedPoolId interface{}, dmClusterId interface{}, masterNodeQuota interface{}, workerNodeQuota interface{}, force interface{}) *Service_ScaleDMCluster_Call {
	return &Service_ScaleDMCluster_Call{Call: _e.mock.On("ScaleDMCluster", ctx, sharedPoolId, dmClusterId, masterNodeQuota, workerNodeQuota, force)}
}

func (_c *Service_ScaleDMCluster_Call) Run(run func(ctx context.Context, sharedPoolId string, dmClusterId string, masterNodeQuota *entity.NodeQuota, workerNodeQuota *entity.NodeQuota, force bool)) *Service_ScaleDMCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *entity.NodeQuota
		if args[3] != nil {
			arg3 = args[3].(*entity.NodeQuota)
		}
		var arg4 *entity.NodeQuota
		if args[4] != nil {
			arg4 = args[4].(*entity.NodeQuota)
		}
		var arg5 bool
		if args[5] != nil {
			arg5 = args[5].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_ScaleDMCluster_Call) Return(v *entity.DMCluster, err error) *Service_ScaleDMCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_ScaleDMCluster_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, dmClusterId string, masterNodeQuota *entity.NodeQuota, workerNodeQuota *entity.NodeQuota, force bool) (*entity.DMCluster, error)) *Service_ScaleDMCluster_Call {
	_c.Call.Return(run)
	return _c
}

// ScaleSharedPool provides a mock function for the type Service
func (_mock *Service) ScaleSharedPool(ctx context.Context, sharedPoolId string, scaleComponent *entity.Component, force bool) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, scaleComponent, force)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.Component, bool) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, scaleComponent, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.Component, bool) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, scaleComponent, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.Component, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, scaleComponent, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ScaleSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - scaleComponent *entity.Component
//   - force bool
func (_e *Service_Expecter) ScaleSharedPool(ctx interface{}, sharedPoolId interface{}, scaleComponent interface{}, force interface{}) *Service_ScaleSharedPool_Call {
	return &Service_ScaleSharedPool_Call{Call: _e.mock.On("ScaleSharedPool", ctx, sharedPoolId, scaleComponent, force)}
}

func (_c *Service_ScaleSharedPool_Call) Run(run func(ctx context.Context, sharedPoolId string, scaleComponent *entity.Component, force bool)) *Service_ScaleSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *entity.Component
		if args[2] != nil {
			arg2 = args[2].(*entity.Component)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_ScaleSharedPool_Call) Return(sharedPool *entity.SharedPool, err error) *Service_ScaleSharedPool_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_ScaleSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, scaleComponent *entity.Component, force bool) (*entity.SharedPool, error)) *Service_ScaleSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// SetAuditLogSetting provides a mock function for the type Service
func (_mock *Service) SetAuditLogSetting(ctx context.Context, tidbClusterId string, auditLogSetting *entity.AuditLogSetting) (*entity.AuditLogSetting, error) {
	ret := _mock.Called(ctx, tidbClusterId, auditLogSetting)

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

	var r0 *entity.AuditLogSetting
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.AuditLogSetting) (*entity.AuditLogSetting, error)); ok {
		return returnFunc(ctx, tidbClusterId, auditLogSetting)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.AuditLogSetting) *entity.AuditLogSetting); ok {
		r0 = returnFunc(ctx, tidbClusterId, auditLogSetting)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AuditLogSetting)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.AuditLogSetting) error); ok {
		r1 = returnFunc(ctx, tidbClusterId, auditLogSetting)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetAuditLogSetting is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - auditLogSetting *entity.AuditLogSetting
func (_e *Service_Expecter) SetAuditLogSetting(ctx interface{}, tidbClusterId interface{}, auditLogSetting interface{}) *Service_SetAuditLogSetting_Call {
	return &Service_SetAuditLogSetting_Call{Call: _e.mock.On("SetAuditLogSetting", ctx, tidbClusterId, auditLogSetting)}
}

func (_c *Service_SetAuditLogSetting_Call) Run(run func(ctx context.Context, tidbClusterId string, auditLogSetting *entity.AuditLogSetting)) *Service_SetAuditLogSetting_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *entity.AuditLogSetting
		if args[2] != nil {
			arg2 = args[2].(*entity.AuditLogSetting)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_SetAuditLogSetting_Call) Return(v *entity.AuditLogSetting, err error) *Service_SetAuditLogSetting_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetAuditLogSetting_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, auditLogSetting *entity.AuditLogSetting) (*entity.AuditLogSetting, error)) *Service_SetAuditLogSetting_Call {
	_c.Call.Return(run)
	return _c
}

// SetBrComponentConfigOrVersion provides a mock function for the type Service
func (_mock *Service) SetBrComponentConfigOrVersion(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope) error {
	ret := _mock.Called(ctx, sharedPoolId, targetComponents, scope)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.TargetComponent, entity.SetVersionConfigScope) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetComponents, scope)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetBrComponentConfigOrVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetComponents []*entity.TargetComponent
//   - scope entity.SetVersionConfigScope
func (_e *Service_Expecter) SetBrComponentConfigOrVersion(ctx interface{}, sharedPoolId interface{}, targetComponents interface{}, scope interface{}) *Service_SetBrComponentConfigOrVersion_Call {
	return &Service_SetBrComponentConfigOrVersion_Call{Call: _e.mock.On("SetBrComponentConfigOrVersion", ctx, sharedPoolId, targetComponents, scope)}
}

func (_c *Service_SetBrComponentConfigOrVersion_Call) Run(run func(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope)) *Service_SetBrComponentConfigOrVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []*entity.TargetComponent
		if args[2] != nil {
			arg2 = args[2].([]*entity.TargetComponent)
		}
		var arg3 entity.SetVersionConfigScope
		if args[3] != nil {
			arg3 = args[3].(entity.SetVersionConfigScope)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_SetBrComponentConfigOrVersion_Call) Return(err error) *Service_SetBrComponentConfigOrVersion_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetBrComponentConfigOrVersion_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope) error) *Service_SetBrComponentConfigOrVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetCassandraProxy provides a mock function for the type Service
func (_mock *Service) SetCassandraProxy(ctx context.Context, req *cluster_service_ngv1beta.SetCassandraProxyRequest) (*cluster_service_ngv1beta.SetCassandraProxyResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *cluster_service_ngv1beta.SetCassandraProxyResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.SetCassandraProxyRequest) (*cluster_service_ngv1beta.SetCassandraProxyResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.SetCassandraProxyRequest) *cluster_service_ngv1beta.SetCassandraProxyResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cluster_service_ngv1beta.SetCassandraProxyResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *cluster_service_ngv1beta.SetCassandraProxyRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetCassandraProxy is a helper method to define mock.On call
//   - ctx context.Context
//   - req *cluster_service_ngv1beta.SetCassandraProxyRequest
func (_e *Service_Expecter) SetCassandraProxy(ctx interface{}, req interface{}) *Service_SetCassandraProxy_Call {
	return &Service_SetCassandraProxy_Call{Call: _e.mock.On("SetCassandraProxy", ctx, req)}
}

func (_c *Service_SetCassandraProxy_Call) Run(run func(ctx context.Context, req *cluster_service_ngv1beta.SetCassandraProxyRequest)) *Service_SetCassandraProxy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *cluster_service_ngv1beta.SetCassandraProxyRequest
		if args[1] != nil {
			arg1 = args[1].(*cluster_service_ngv1beta.SetCassandraProxyRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_SetCassandraProxy_Call) Return(setCassandraProxyResponse *cluster_service_ngv1beta.SetCassandraProxyResponse, err error) *Service_SetCassandraProxy_Call {
	_c.Call.Return(setCassandraProxyResponse, err)
	return _c
}

func (_c *Service_SetCassandraProxy_Call) RunAndReturn(run func(ctx context.Context, req *cluster_service_ngv1beta.SetCassandraProxyRequest) (*cluster_service_ngv1beta.SetCassandraProxyResponse, error)) *Service_SetCassandraProxy_Call {
	_c.Call.Return(run)
	return _c
}

// SetComponentTemplateVersionStatus provides a mock function for the type Service
func (_mock *Service) SetComponentTemplateVersionStatus(ctx context.Context, componentType entity.ComponentType, version string, status entity.TemplateVersionStatus) (*entity.TemplateVersionInfo, error) {
	ret := _mock.Called(ctx, componentType, version, status)

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

	var r0 *entity.TemplateVersionInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ComponentType, string, entity.TemplateVersionStatus) (*entity.TemplateVersionInfo, error)); ok {
		return returnFunc(ctx, componentType, version, status)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ComponentType, string, entity.TemplateVersionStatus) *entity.TemplateVersionInfo); ok {
		r0 = returnFunc(ctx, componentType, version, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TemplateVersionInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.ComponentType, string, entity.TemplateVersionStatus) error); ok {
		r1 = returnFunc(ctx, componentType, version, status)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetComponentTemplateVersionStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - componentType entity.ComponentType
//   - version string
//   - status entity.TemplateVersionStatus
func (_e *Service_Expecter) SetComponentTemplateVersionStatus(ctx interface{}, componentType interface{}, version interface{}, status interface{}) *Service_SetComponentTemplateVersionStatus_Call {
	return &Service_SetComponentTemplateVersionStatus_Call{Call: _e.mock.On("SetComponentTemplateVersionStatus", ctx, componentType, version, status)}
}

func (_c *Service_SetComponentTemplateVersionStatus_Call) Run(run func(ctx context.Context, componentType entity.ComponentType, version string, status entity.TemplateVersionStatus)) *Service_SetComponentTemplateVersionStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.ComponentType
		if args[1] != nil {
			arg1 = args[1].(entity.ComponentType)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.TemplateVersionStatus
		if args[3] != nil {
			arg3 = args[3].(entity.TemplateVersionStatus)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_SetComponentTemplateVersionStatus_Call) Return(v *entity.TemplateVersionInfo, err error) *Service_SetComponentTemplateVersionStatus_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetComponentTemplateVersionStatus_Call) RunAndReturn(run func(ctx context.Context, componentType entity.ComponentType, version string, status entity.TemplateVersionStatus) (*entity.TemplateVersionInfo, error)) *Service_SetComponentTemplateVersionStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetDMComponentConfigOrVersion provides a mock function for the type Service
func (_mock *Service) SetDMComponentConfigOrVersion(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope, force bool) error {
	ret := _mock.Called(ctx, sharedPoolId, targetComponents, scope, force)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.TargetComponent, entity.SetVersionConfigScope, bool) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetComponents, scope, force)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetDMComponentConfigOrVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetComponents []*entity.TargetComponent
//   - scope entity.SetVersionConfigScope
//   - force bool
func (_e *Service_Expecter) SetDMComponentConfigOrVersion(ctx interface{}, sharedPoolId interface{}, targetComponents interface{}, scope interface{}, force interface{}) *Service_SetDMComponentConfigOrVersion_Call {
	return &Service_SetDMComponentConfigOrVersion_Call{Call: _e.mock.On("SetDMComponentConfigOrVersion", ctx, sharedPoolId, targetComponents, scope, force)}
}

func (_c *Service_SetDMComponentConfigOrVersion_Call) Run(run func(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope, force bool)) *Service_SetDMComponentConfigOrVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []*entity.TargetComponent
		if args[2] != nil {
			arg2 = args[2].([]*entity.TargetComponent)
		}
		var arg3 entity.SetVersionConfigScope
		if args[3] != nil {
			arg3 = args[3].(entity.SetVersionConfigScope)
		}
		var arg4 bool
		if args[4] != nil {
			arg4 = args[4].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_SetDMComponentConfigOrVersion_Call) Return(err error) *Service_SetDMComponentConfigOrVersion_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetDMComponentConfigOrVersion_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope, force bool) error) *Service_SetDMComponentConfigOrVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetDataplaneNodeInstanceGroupStatus provides a mock function for the type Service
func (_mock *Service) SetDataplaneNodeInstanceGroupStatus(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, status cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status) (*entity.DataplaneNodeInstanceGroup, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance, status)

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

	var r0 *entity.DataplaneNodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status) (*entity.DataplaneNodeInstanceGroup, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, status)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status) *entity.DataplaneNodeInstanceGroup); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, status)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetDataplaneNodeInstanceGroupStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
//   - status cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status
func (_e *Service_Expecter) SetDataplaneNodeInstanceGroupStatus(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}, status interface{}) *Service_SetDataplaneNodeInstanceGroupStatus_Call {
	return &Service_SetDataplaneNodeInstanceGroupStatus_Call{Call: _e.mock.On("SetDataplaneNodeInstanceGroupStatus", ctx, dataplaneName, nodeSpec, primaryInstance, status)}
}

func (_c *Service_SetDataplaneNodeInstanceGroupStatus_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, status cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status)) *Service_SetDataplaneNodeInstanceGroupStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status
		if args[4] != nil {
			arg4 = args[4].(cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_SetDataplaneNodeInstanceGroupStatus_Call) Return(v *entity.DataplaneNodeInstanceGroup, err error) *Service_SetDataplaneNodeInstanceGroupStatus_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetDataplaneNodeInstanceGroupStatus_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, status cluster_service_ngv1beta.DataplaneNodeInstanceGroup_Status) (*entity.DataplaneNodeInstanceGroup, error)) *Service_SetDataplaneNodeInstanceGroupStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetHPAScaleBehavior provides a mock function for the type Service
func (_mock *Service) SetHPAScaleBehavior(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, scaleUpEnabled *bool, scaleDownEnabled *bool) error {
	ret := _mock.Called(ctx, sharedPoolId, groupId, componentType, scaleUpEnabled, scaleDownEnabled)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.ComponentType, *bool, *bool) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, groupId, componentType, scaleUpEnabled, scaleDownEnabled)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetHPAScaleBehavior is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - groupId string
//   - componentType entity.ComponentType
//   - scaleUpEnabled *bool
//   - scaleDownEnabled *bool
func (_e *Service_Expecter) SetHPAScaleBehavior(ctx interface{}, sharedPoolId interface{}, groupId interface{}, componentType interface{}, scaleUpEnabled interface{}, scaleDownEnabled interface{}) *Service_SetHPAScaleBehavior_Call {
	return &Service_SetHPAScaleBehavior_Call{Call: _e.mock.On("SetHPAScaleBehavior", ctx, sharedPoolId, groupId, componentType, scaleUpEnabled, scaleDownEnabled)}
}

func (_c *Service_SetHPAScaleBehavior_Call) Run(run func(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, scaleUpEnabled *bool, scaleDownEnabled *bool)) *Service_SetHPAScaleBehavior_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.ComponentType
		if args[3] != nil {
			arg3 = args[3].(entity.ComponentType)
		}
		var arg4 *bool
		if args[4] != nil {
			arg4 = args[4].(*bool)
		}
		var arg5 *bool
		if args[5] != nil {
			arg5 = args[5].(*bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_SetHPAScaleBehavior_Call) Return(err error) *Service_SetHPAScaleBehavior_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetHPAScaleBehavior_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, scaleUpEnabled *bool, scaleDownEnabled *bool) error) *Service_SetHPAScaleBehavior_Call {
	_c.Call.Return(run)
	return _c
}

// SetHPASpec provides a mock function for the type Service
func (_mock *Service) SetHPASpec(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, spec *entity.HorizontalPodAutoscalerSpec) error {
	ret := _mock.Called(ctx, sharedPoolId, groupId, componentType, spec)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.ComponentType, *entity.HorizontalPodAutoscalerSpec) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, groupId, componentType, spec)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetHPASpec is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - groupId string
//   - componentType entity.ComponentType
//   - spec *entity.HorizontalPodAutoscalerSpec
func (_e *Service_Expecter) SetHPASpec(ctx interface{}, sharedPoolId interface{}, groupId interface{}, componentType interface{}, spec interface{}) *Service_SetHPASpec_Call {
	return &Service_SetHPASpec_Call{Call: _e.mock.On("SetHPASpec", ctx, sharedPoolId, groupId, componentType, spec)}
}

func (_c *Service_SetHPASpec_Call) Run(run func(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, spec *entity.HorizontalPodAutoscalerSpec)) *Service_SetHPASpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.ComponentType
		if args[3] != nil {
			arg3 = args[3].(entity.ComponentType)
		}
		var arg4 *entity.HorizontalPodAutoscalerSpec
		if args[4] != nil {
			arg4 = args[4].(*entity.HorizontalPodAutoscalerSpec)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_SetHPASpec_Call) Return(err error) *Service_SetHPASpec_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetHPASpec_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, spec *entity.HorizontalPodAutoscalerSpec) error) *Service_SetHPASpec_Call {
	_c.Call.Return(run)
	return _c
}

// SetNodeInstanceGroupInstanceTypeStatus provides a mock function for the type Service
func (_mock *Service) SetNodeInstanceGroupInstanceTypeStatus(ctx context.Context, nodeSpec string, primaryInstance string, instanceType string, status cluster_service_ngv1beta.InstanceTypeStatus) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance, instanceType, status)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, cluster_service_ngv1beta.InstanceTypeStatus) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance, instanceType, status)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, cluster_service_ngv1beta.InstanceTypeStatus) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance, instanceType, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, cluster_service_ngv1beta.InstanceTypeStatus) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance, instanceType, status)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetNodeInstanceGroupInstanceTypeStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
//   - instanceType string
//   - status cluster_service_ngv1beta.InstanceTypeStatus
func (_e *Service_Expecter) SetNodeInstanceGroupInstanceTypeStatus(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}, instanceType interface{}, status interface{}) *Service_SetNodeInstanceGroupInstanceTypeStatus_Call {
	return &Service_SetNodeInstanceGroupInstanceTypeStatus_Call{Call: _e.mock.On("SetNodeInstanceGroupInstanceTypeStatus", ctx, nodeSpec, primaryInstance, instanceType, status)}
}

func (_c *Service_SetNodeInstanceGroupInstanceTypeStatus_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string, instanceType string, status cluster_service_ngv1beta.InstanceTypeStatus)) *Service_SetNodeInstanceGroupInstanceTypeStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 cluster_service_ngv1beta.InstanceTypeStatus
		if args[4] != nil {
			arg4 = args[4].(cluster_service_ngv1beta.InstanceTypeStatus)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_SetNodeInstanceGroupInstanceTypeStatus_Call) Return(v *entity.NodeInstanceGroup, err error) *Service_SetNodeInstanceGroupInstanceTypeStatus_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetNodeInstanceGroupInstanceTypeStatus_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string, instanceType string, status cluster_service_ngv1beta.InstanceTypeStatus) (*entity.NodeInstanceGroup, error)) *Service_SetNodeInstanceGroupInstanceTypeStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetNodeInstanceGroupStatus provides a mock function for the type Service
func (_mock *Service) SetNodeInstanceGroupStatus(ctx context.Context, nodeSpec string, primaryInstance string, nodeGroupStatus cluster_service_ngv1beta.NodeInstanceGroup_Status) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance, nodeGroupStatus)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, cluster_service_ngv1beta.NodeInstanceGroup_Status) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance, nodeGroupStatus)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, cluster_service_ngv1beta.NodeInstanceGroup_Status) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance, nodeGroupStatus)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, cluster_service_ngv1beta.NodeInstanceGroup_Status) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance, nodeGroupStatus)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetNodeInstanceGroupStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
//   - nodeGroupStatus cluster_service_ngv1beta.NodeInstanceGroup_Status
func (_e *Service_Expecter) SetNodeInstanceGroupStatus(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}, nodeGroupStatus interface{}) *Service_SetNodeInstanceGroupStatus_Call {
	return &Service_SetNodeInstanceGroupStatus_Call{Call: _e.mock.On("SetNodeInstanceGroupStatus", ctx, nodeSpec, primaryInstance, nodeGroupStatus)}
}

func (_c *Service_SetNodeInstanceGroupStatus_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string, nodeGroupStatus cluster_service_ngv1beta.NodeInstanceGroup_Status)) *Service_SetNodeInstanceGroupStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 cluster_service_ngv1beta.NodeInstanceGroup_Status
		if args[3] != nil {
			arg3 = args[3].(cluster_service_ngv1beta.NodeInstanceGroup_Status)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_SetNodeInstanceGroupStatus_Call) Return(v *entity.NodeInstanceGroup, err error) *Service_SetNodeInstanceGroupStatus_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetNodeInstanceGroupStatus_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string, nodeGroupStatus cluster_service_ngv1beta.NodeInstanceGroup_Status) (*entity.NodeInstanceGroup, error)) *Service_SetNodeInstanceGroupStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetRuConfig provides a mock function for the type Service
func (_mock *Service) SetRuConfig(ctx context.Context, id string, scope entity.RuConfigScope, ruConfig *entity.RuConfig) (*entity.RuConfig, error) {
	ret := _mock.Called(ctx, id, scope, ruConfig)

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

	var r0 *entity.RuConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope, *entity.RuConfig) (*entity.RuConfig, error)); ok {
		return returnFunc(ctx, id, scope, ruConfig)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope, *entity.RuConfig) *entity.RuConfig); ok {
		r0 = returnFunc(ctx, id, scope, ruConfig)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.RuConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.RuConfigScope, *entity.RuConfig) error); ok {
		r1 = returnFunc(ctx, id, scope, ruConfig)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetRuConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
//   - ruConfig *entity.RuConfig
func (_e *Service_Expecter) SetRuConfig(ctx interface{}, id interface{}, scope interface{}, ruConfig interface{}) *Service_SetRuConfig_Call {
	return &Service_SetRuConfig_Call{Call: _e.mock.On("SetRuConfig", ctx, id, scope, ruConfig)}
}

func (_c *Service_SetRuConfig_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope, ruConfig *entity.RuConfig)) *Service_SetRuConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		var arg3 *entity.RuConfig
		if args[3] != nil {
			arg3 = args[3].(*entity.RuConfig)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_SetRuConfig_Call) Return(ruConfig1 *entity.RuConfig, err error) *Service_SetRuConfig_Call {
	_c.Call.Return(ruConfig1, err)
	return _c
}

func (_c *Service_SetRuConfig_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope, ruConfig *entity.RuConfig) (*entity.RuConfig, error)) *Service_SetRuConfig_Call {
	_c.Call.Return(run)
	return _c
}

// SetScaleOutConfig provides a mock function for the type Service
func (_mock *Service) SetScaleOutConfig(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, config *entity.ScaleOutConfig) error {
	ret := _mock.Called(ctx, sharedPoolId, groupId, componentType, config)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.ComponentType, *entity.ScaleOutConfig) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, groupId, componentType, config)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetScaleOutConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - groupId string
//   - componentType entity.ComponentType
//   - config *entity.ScaleOutConfig
func (_e *Service_Expecter) SetScaleOutConfig(ctx interface{}, sharedPoolId interface{}, groupId interface{}, componentType interface{}, config interface{}) *Service_SetScaleOutConfig_Call {
	return &Service_SetScaleOutConfig_Call{Call: _e.mock.On("SetScaleOutConfig", ctx, sharedPoolId, groupId, componentType, config)}
}

func (_c *Service_SetScaleOutConfig_Call) Run(run func(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, config *entity.ScaleOutConfig)) *Service_SetScaleOutConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.ComponentType
		if args[3] != nil {
			arg3 = args[3].(entity.ComponentType)
		}
		var arg4 *entity.ScaleOutConfig
		if args[4] != nil {
			arg4 = args[4].(*entity.ScaleOutConfig)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_SetScaleOutConfig_Call) Return(err error) *Service_SetScaleOutConfig_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetScaleOutConfig_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, groupId string, componentType entity.ComponentType, config *entity.ScaleOutConfig) error) *Service_SetScaleOutConfig_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedPoolComponentConfigOrVersion provides a mock function for the type Service
func (_mock *Service) SetSharedPoolComponentConfigOrVersion(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope, mode entity.SetVersionConfigMode, force bool) error {
	ret := _mock.Called(ctx, sharedPoolId, targetComponents, scope, mode, force)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*entity.TargetComponent, entity.SetVersionConfigScope, entity.SetVersionConfigMode, bool) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetComponents, scope, mode, force)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetSharedPoolComponentConfigOrVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetComponents []*entity.TargetComponent
//   - scope entity.SetVersionConfigScope
//   - mode entity.SetVersionConfigMode
//   - force bool
func (_e *Service_Expecter) SetSharedPoolComponentConfigOrVersion(ctx interface{}, sharedPoolId interface{}, targetComponents interface{}, scope interface{}, mode interface{}, force interface{}) *Service_SetSharedPoolComponentConfigOrVersion_Call {
	return &Service_SetSharedPoolComponentConfigOrVersion_Call{Call: _e.mock.On("SetSharedPoolComponentConfigOrVersion", ctx, sharedPoolId, targetComponents, scope, mode, force)}
}

func (_c *Service_SetSharedPoolComponentConfigOrVersion_Call) Run(run func(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope, mode entity.SetVersionConfigMode, force bool)) *Service_SetSharedPoolComponentConfigOrVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []*entity.TargetComponent
		if args[2] != nil {
			arg2 = args[2].([]*entity.TargetComponent)
		}
		var arg3 entity.SetVersionConfigScope
		if args[3] != nil {
			arg3 = args[3].(entity.SetVersionConfigScope)
		}
		var arg4 entity.SetVersionConfigMode
		if args[4] != nil {
			arg4 = args[4].(entity.SetVersionConfigMode)
		}
		var arg5 bool
		if args[5] != nil {
			arg5 = args[5].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *Service_SetSharedPoolComponentConfigOrVersion_Call) Return(err error) *Service_SetSharedPoolComponentConfigOrVersion_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetSharedPoolComponentConfigOrVersion_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetComponents []*entity.TargetComponent, scope entity.SetVersionConfigScope, mode entity.SetVersionConfigMode, force bool) error) *Service_SetSharedPoolComponentConfigOrVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedPoolComponentLabels provides a mock function for the type Service
func (_mock *Service) SetSharedPoolComponentLabels(ctx context.Context, sharedPoolId string, targetComponent *entity.Component) (*entity.Component, error) {
	ret := _mock.Called(ctx, sharedPoolId, targetComponent)

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

	var r0 *entity.Component
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.Component) (*entity.Component, error)); ok {
		return returnFunc(ctx, sharedPoolId, targetComponent)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.Component) *entity.Component); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetComponent)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Component)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.Component) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, targetComponent)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetSharedPoolComponentLabels is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetComponent *entity.Component
func (_e *Service_Expecter) SetSharedPoolComponentLabels(ctx interface{}, sharedPoolId interface{}, targetComponent interface{}) *Service_SetSharedPoolComponentLabels_Call {
	return &Service_SetSharedPoolComponentLabels_Call{Call: _e.mock.On("SetSharedPoolComponentLabels", ctx, sharedPoolId, targetComponent)}
}

func (_c *Service_SetSharedPoolComponentLabels_Call) Run(run func(ctx context.Context, sharedPoolId string, targetComponent *entity.Component)) *Service_SetSharedPoolComponentLabels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *entity.Component
		if args[2] != nil {
			arg2 = args[2].(*entity.Component)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_SetSharedPoolComponentLabels_Call) Return(v *entity.Component, err error) *Service_SetSharedPoolComponentLabels_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetSharedPoolComponentLabels_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetComponent *entity.Component) (*entity.Component, error)) *Service_SetSharedPoolComponentLabels_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedPoolComponentNodeVersion provides a mock function for the type Service
func (_mock *Service) SetSharedPoolComponentNodeVersion(ctx context.Context, sharedPoolId string, compId string, compType cluster_service_ngv1beta.ComponentType, nodeVersion string) (*entity.Component, error) {
	ret := _mock.Called(ctx, sharedPoolId, compId, compType, nodeVersion)

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

	var r0 *entity.Component
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, cluster_service_ngv1beta.ComponentType, string) (*entity.Component, error)); ok {
		return returnFunc(ctx, sharedPoolId, compId, compType, nodeVersion)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, cluster_service_ngv1beta.ComponentType, string) *entity.Component); ok {
		r0 = returnFunc(ctx, sharedPoolId, compId, compType, nodeVersion)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Component)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, cluster_service_ngv1beta.ComponentType, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, compId, compType, nodeVersion)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetSharedPoolComponentNodeVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - compId string
//   - compType cluster_service_ngv1beta.ComponentType
//   - nodeVersion string
func (_e *Service_Expecter) SetSharedPoolComponentNodeVersion(ctx interface{}, sharedPoolId interface{}, compId interface{}, compType interface{}, nodeVersion interface{}) *Service_SetSharedPoolComponentNodeVersion_Call {
	return &Service_SetSharedPoolComponentNodeVersion_Call{Call: _e.mock.On("SetSharedPoolComponentNodeVersion", ctx, sharedPoolId, compId, compType, nodeVersion)}
}

func (_c *Service_SetSharedPoolComponentNodeVersion_Call) Run(run func(ctx context.Context, sharedPoolId string, compId string, compType cluster_service_ngv1beta.ComponentType, nodeVersion string)) *Service_SetSharedPoolComponentNodeVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 cluster_service_ngv1beta.ComponentType
		if args[3] != nil {
			arg3 = args[3].(cluster_service_ngv1beta.ComponentType)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_SetSharedPoolComponentNodeVersion_Call) Return(v *entity.Component, err error) *Service_SetSharedPoolComponentNodeVersion_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetSharedPoolComponentNodeVersion_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, compId string, compType cluster_service_ngv1beta.ComponentType, nodeVersion string) (*entity.Component, error)) *Service_SetSharedPoolComponentNodeVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedPoolComponentQuota provides a mock function for the type Service
func (_mock *Service) SetSharedPoolComponentQuota(ctx context.Context, sharedPoolId string, targetComponent *entity.Component) (*entity.Component, error) {
	ret := _mock.Called(ctx, sharedPoolId, targetComponent)

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

	var r0 *entity.Component
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.Component) (*entity.Component, error)); ok {
		return returnFunc(ctx, sharedPoolId, targetComponent)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.Component) *entity.Component); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetComponent)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Component)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.Component) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, targetComponent)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetSharedPoolComponentQuota is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetComponent *entity.Component
func (_e *Service_Expecter) SetSharedPoolComponentQuota(ctx interface{}, sharedPoolId interface{}, targetComponent interface{}) *Service_SetSharedPoolComponentQuota_Call {
	return &Service_SetSharedPoolComponentQuota_Call{Call: _e.mock.On("SetSharedPoolComponentQuota", ctx, sharedPoolId, targetComponent)}
}

func (_c *Service_SetSharedPoolComponentQuota_Call) Run(run func(ctx context.Context, sharedPoolId string, targetComponent *entity.Component)) *Service_SetSharedPoolComponentQuota_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *entity.Component
		if args[2] != nil {
			arg2 = args[2].(*entity.Component)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_SetSharedPoolComponentQuota_Call) Return(v *entity.Component, err error) *Service_SetSharedPoolComponentQuota_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetSharedPoolComponentQuota_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetComponent *entity.Component) (*entity.Component, error)) *Service_SetSharedPoolComponentQuota_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedPoolPDDeploymentMode provides a mock function for the type Service
func (_mock *Service) SetSharedPoolPDDeploymentMode(ctx context.Context, sharedPoolId string, targetMode entity.PDDeploymentMode) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, targetMode)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PDDeploymentMode) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, targetMode)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PDDeploymentMode) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetMode)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.PDDeploymentMode) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, targetMode)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetSharedPoolPDDeploymentMode is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetMode entity.PDDeploymentMode
func (_e *Service_Expecter) SetSharedPoolPDDeploymentMode(ctx interface{}, sharedPoolId interface{}, targetMode interface{}) *Service_SetSharedPoolPDDeploymentMode_Call {
	return &Service_SetSharedPoolPDDeploymentMode_Call{Call: _e.mock.On("SetSharedPoolPDDeploymentMode", ctx, sharedPoolId, targetMode)}
}

func (_c *Service_SetSharedPoolPDDeploymentMode_Call) Run(run func(ctx context.Context, sharedPoolId string, targetMode entity.PDDeploymentMode)) *Service_SetSharedPoolPDDeploymentMode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.PDDeploymentMode
		if args[2] != nil {
			arg2 = args[2].(entity.PDDeploymentMode)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_SetSharedPoolPDDeploymentMode_Call) Return(sharedPool *entity.SharedPool, err error) *Service_SetSharedPoolPDDeploymentMode_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_SetSharedPoolPDDeploymentMode_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetMode entity.PDDeploymentMode) (*entity.SharedPool, error)) *Service_SetSharedPoolPDDeploymentMode_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedPoolTiKVRemoteWorkers provides a mock function for the type Service
func (_mock *Service) SetSharedPoolTiKVRemoteWorkers(ctx context.Context, sharedPoolId string, targetWorkers []entity.ComponentType) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, targetWorkers)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []entity.ComponentType) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, targetWorkers)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []entity.ComponentType) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, targetWorkers)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, []entity.ComponentType) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, targetWorkers)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetSharedPoolTiKVRemoteWorkers is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - targetWorkers []entity.ComponentType
func (_e *Service_Expecter) SetSharedPoolTiKVRemoteWorkers(ctx interface{}, sharedPoolId interface{}, targetWorkers interface{}) *Service_SetSharedPoolTiKVRemoteWorkers_Call {
	return &Service_SetSharedPoolTiKVRemoteWorkers_Call{Call: _e.mock.On("SetSharedPoolTiKVRemoteWorkers", ctx, sharedPoolId, targetWorkers)}
}

func (_c *Service_SetSharedPoolTiKVRemoteWorkers_Call) Run(run func(ctx context.Context, sharedPoolId string, targetWorkers []entity.ComponentType)) *Service_SetSharedPoolTiKVRemoteWorkers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []entity.ComponentType
		if args[2] != nil {
			arg2 = args[2].([]entity.ComponentType)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_SetSharedPoolTiKVRemoteWorkers_Call) Return(sharedPool *entity.SharedPool, err error) *Service_SetSharedPoolTiKVRemoteWorkers_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_SetSharedPoolTiKVRemoteWorkers_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, targetWorkers []entity.ComponentType) (*entity.SharedPool, error)) *Service_SetSharedPoolTiKVRemoteWorkers_Call {
	_c.Call.Return(run)
	return _c
}

// SetTemplateVersionStatus provides a mock function for the type Service
func (_mock *Service) SetTemplateVersionStatus(ctx context.Context, templateName string, version string, status entity.TemplateVersionStatus) (*entity.TemplateVersionInfo, error) {
	ret := _mock.Called(ctx, templateName, version, status)

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

	var r0 *entity.TemplateVersionInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.TemplateVersionStatus) (*entity.TemplateVersionInfo, error)); ok {
		return returnFunc(ctx, templateName, version, status)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.TemplateVersionStatus) *entity.TemplateVersionInfo); ok {
		r0 = returnFunc(ctx, templateName, version, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TemplateVersionInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, entity.TemplateVersionStatus) error); ok {
		r1 = returnFunc(ctx, templateName, version, status)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetTemplateVersionStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
//   - version string
//   - status entity.TemplateVersionStatus
func (_e *Service_Expecter) SetTemplateVersionStatus(ctx interface{}, templateName interface{}, version interface{}, status interface{}) *Service_SetTemplateVersionStatus_Call {
	return &Service_SetTemplateVersionStatus_Call{Call: _e.mock.On("SetTemplateVersionStatus", ctx, templateName, version, status)}
}

func (_c *Service_SetTemplateVersionStatus_Call) Run(run func(ctx context.Context, templateName string, version string, status entity.TemplateVersionStatus)) *Service_SetTemplateVersionStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.TemplateVersionStatus
		if args[3] != nil {
			arg3 = args[3].(entity.TemplateVersionStatus)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_SetTemplateVersionStatus_Call) Return(v *entity.TemplateVersionInfo, err error) *Service_SetTemplateVersionStatus_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SetTemplateVersionStatus_Call) RunAndReturn(run func(ctx context.Context, templateName string, version string, status entity.TemplateVersionStatus) (*entity.TemplateVersionInfo, error)) *Service_SetTemplateVersionStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetTiProxyExternalDNS provides a mock function for the type Service
func (_mock *Service) SetTiProxyExternalDNS(ctx context.Context, req *entity.SetTiProxyExternalDNSRequest) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SetTiProxyExternalDNSRequest) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetTiProxyExternalDNS is a helper method to define mock.On call
//   - ctx context.Context
//   - req *entity.SetTiProxyExternalDNSRequest
func (_e *Service_Expecter) SetTiProxyExternalDNS(ctx interface{}, req interface{}) *Service_SetTiProxyExternalDNS_Call {
	return &Service_SetTiProxyExternalDNS_Call{Call: _e.mock.On("SetTiProxyExternalDNS", ctx, req)}
}

func (_c *Service_SetTiProxyExternalDNS_Call) Run(run func(ctx context.Context, req *entity.SetTiProxyExternalDNSRequest)) *Service_SetTiProxyExternalDNS_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SetTiProxyExternalDNSRequest
		if args[1] != nil {
			arg1 = args[1].(*entity.SetTiProxyExternalDNSRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_SetTiProxyExternalDNS_Call) Return(err error) *Service_SetTiProxyExternalDNS_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SetTiProxyExternalDNS_Call) RunAndReturn(run func(ctx context.Context, req *entity.SetTiProxyExternalDNSRequest) error) *Service_SetTiProxyExternalDNS_Call {
	_c.Call.Return(run)
	return _c
}

// SyncAutoscalePolicy provides a mock function for the type Service
func (_mock *Service) SyncAutoscalePolicy(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, mode cluster_service_ngv1beta.SyncAutoscalePolicyMode, keys []*entity.AutoscalePolicySpecKey, applyToAllSharedPools *wrapperspb.BoolValue, requestID string) (*entity.AutoscalePolicyResponse, error) {
	ret := _mock.Called(ctx, scope, subjectID, mode, keys, applyToAllSharedPools, requestID)

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

	var r0 *entity.AutoscalePolicyResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, cluster_service_ngv1beta.SyncAutoscalePolicyMode, []*entity.AutoscalePolicySpecKey, *wrapperspb.BoolValue, string) (*entity.AutoscalePolicyResponse, error)); ok {
		return returnFunc(ctx, scope, subjectID, mode, keys, applyToAllSharedPools, requestID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, cluster_service_ngv1beta.SyncAutoscalePolicyMode, []*entity.AutoscalePolicySpecKey, *wrapperspb.BoolValue, string) *entity.AutoscalePolicyResponse); ok {
		r0 = returnFunc(ctx, scope, subjectID, mode, keys, applyToAllSharedPools, requestID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscalePolicyResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string, cluster_service_ngv1beta.SyncAutoscalePolicyMode, []*entity.AutoscalePolicySpecKey, *wrapperspb.BoolValue, string) error); ok {
		r1 = returnFunc(ctx, scope, subjectID, mode, keys, applyToAllSharedPools, requestID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SyncAutoscalePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
//   - mode cluster_service_ngv1beta.SyncAutoscalePolicyMode
//   - keys []*entity.AutoscalePolicySpecKey
//   - applyToAllSharedPools *wrapperspb.BoolValue
//   - requestID string
func (_e *Service_Expecter) SyncAutoscalePolicy(ctx interface{}, scope interface{}, subjectID interface{}, mode interface{}, keys interface{}, applyToAllSharedPools interface{}, requestID interface{}) *Service_SyncAutoscalePolicy_Call {
	return &Service_SyncAutoscalePolicy_Call{Call: _e.mock.On("SyncAutoscalePolicy", ctx, scope, subjectID, mode, keys, applyToAllSharedPools, requestID)}
}

func (_c *Service_SyncAutoscalePolicy_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, mode cluster_service_ngv1beta.SyncAutoscalePolicyMode, keys []*entity.AutoscalePolicySpecKey, applyToAllSharedPools *wrapperspb.BoolValue, requestID string)) *Service_SyncAutoscalePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 cluster_service_ngv1beta.SyncAutoscalePolicyMode
		if args[3] != nil {
			arg3 = args[3].(cluster_service_ngv1beta.SyncAutoscalePolicyMode)
		}
		var arg4 []*entity.AutoscalePolicySpecKey
		if args[4] != nil {
			arg4 = args[4].([]*entity.AutoscalePolicySpecKey)
		}
		var arg5 *wrapperspb.BoolValue
		if args[5] != nil {
			arg5 = args[5].(*wrapperspb.BoolValue)
		}
		var arg6 string
		if args[6] != nil {
			arg6 = args[6].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6,
		)
	})
	return _c
}

func (_c *Service_SyncAutoscalePolicy_Call) Return(v *entity.AutoscalePolicyResponse, err error) *Service_SyncAutoscalePolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_SyncAutoscalePolicy_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string, mode cluster_service_ngv1beta.SyncAutoscalePolicyMode, keys []*entity.AutoscalePolicySpecKey, applyToAllSharedPools *wrapperspb.BoolValue, requestID string) (*entity.AutoscalePolicyResponse, error)) *Service_SyncAutoscalePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// TestClassicBackupAccess provides a mock function for the type Service
func (_mock *Service) TestClassicBackupAccess(ctx context.Context, req *server.TestClassicBackupAccessInput) (*server.TestClassicBackupAccessOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.TestClassicBackupAccessOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.TestClassicBackupAccessInput) (*server.TestClassicBackupAccessOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.TestClassicBackupAccessInput) *server.TestClassicBackupAccessOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.TestClassicBackupAccessOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.TestClassicBackupAccessInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TestClassicBackupAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.TestClassicBackupAccessInput
func (_e *Service_Expecter) TestClassicBackupAccess(ctx interface{}, req interface{}) *Service_TestClassicBackupAccess_Call {
	return &Service_TestClassicBackupAccess_Call{Call: _e.mock.On("TestClassicBackupAccess", ctx, req)}
}

func (_c *Service_TestClassicBackupAccess_Call) Run(run func(ctx context.Context, req *server.TestClassicBackupAccessInput)) *Service_TestClassicBackupAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.TestClassicBackupAccessInput
		if args[1] != nil {
			arg1 = args[1].(*server.TestClassicBackupAccessInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_TestClassicBackupAccess_Call) Return(testClassicBackupAccessOutput *server.TestClassicBackupAccessOutput, err error) *Service_TestClassicBackupAccess_Call {
	_c.Call.Return(testClassicBackupAccessOutput, err)
	return _c
}

func (_c *Service_TestClassicBackupAccess_Call) RunAndReturn(run func(ctx context.Context, req *server.TestClassicBackupAccessInput) (*server.TestClassicBackupAccessOutput, error)) *Service_TestClassicBackupAccess_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAutoBackupMetering provides a mock function for the type Service
func (_mock *Service) UpdateAutoBackupMetering(ctx context.Context, req *cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateAutoBackupMetering is a helper method to define mock.On call
//   - ctx context.Context
//   - req *cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest
func (_e *Service_Expecter) UpdateAutoBackupMetering(ctx interface{}, req interface{}) *Service_UpdateAutoBackupMetering_Call {
	return &Service_UpdateAutoBackupMetering_Call{Call: _e.mock.On("UpdateAutoBackupMetering", ctx, req)}
}

func (_c *Service_UpdateAutoBackupMetering_Call) Run(run func(ctx context.Context, req *cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest)) *Service_UpdateAutoBackupMetering_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest
		if args[1] != nil {
			arg1 = args[1].(*cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_UpdateAutoBackupMetering_Call) Return(err error) *Service_UpdateAutoBackupMetering_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_UpdateAutoBackupMetering_Call) RunAndReturn(run func(ctx context.Context, req *cluster_service_ngv1beta.UpdateAutoBackupMeteringRequest) error) *Service_UpdateAutoBackupMetering_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBackupGcSetting provides a mock function for the type Service
func (_mock *Service) UpdateBackupGcSetting(ctx context.Context, req *server.UpdateBackupGcSettingInput) (*server.UpdateBackupGcSettingOutput, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *server.UpdateBackupGcSettingOutput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.UpdateBackupGcSettingInput) (*server.UpdateBackupGcSettingOutput, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *server.UpdateBackupGcSettingInput) *server.UpdateBackupGcSettingOutput); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*server.UpdateBackupGcSettingOutput)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *server.UpdateBackupGcSettingInput) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateBackupGcSetting is a helper method to define mock.On call
//   - ctx context.Context
//   - req *server.UpdateBackupGcSettingInput
func (_e *Service_Expecter) UpdateBackupGcSetting(ctx interface{}, req interface{}) *Service_UpdateBackupGcSetting_Call {
	return &Service_UpdateBackupGcSetting_Call{Call: _e.mock.On("UpdateBackupGcSetting", ctx, req)}
}

func (_c *Service_UpdateBackupGcSetting_Call) Run(run func(ctx context.Context, req *server.UpdateBackupGcSettingInput)) *Service_UpdateBackupGcSetting_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *server.UpdateBackupGcSettingInput
		if args[1] != nil {
			arg1 = args[1].(*server.UpdateBackupGcSettingInput)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_UpdateBackupGcSetting_Call) Return(updateBackupGcSettingOutput *server.UpdateBackupGcSettingOutput, err error) *Service_UpdateBackupGcSetting_Call {
	_c.Call.Return(updateBackupGcSettingOutput, err)
	return _c
}

func (_c *Service_UpdateBackupGcSetting_Call) RunAndReturn(run func(ctx context.Context, req *server.UpdateBackupGcSettingInput) (*server.UpdateBackupGcSettingOutput, error)) *Service_UpdateBackupGcSetting_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateNodeInstanceGroup provides a mock function for the type Service
func (_mock *Service) UpdateNodeInstanceGroup(ctx context.Context, nodeSpec string, primaryInstance string, fallbackInstances []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance, fallbackInstances)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance, fallbackInstances)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance, fallbackInstances)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance, fallbackInstances)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateNodeInstanceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
//   - fallbackInstances []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance
func (_e *Service_Expecter) UpdateNodeInstanceGroup(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}, fallbackInstances interface{}) *Service_UpdateNodeInstanceGroup_Call {
	return &Service_UpdateNodeInstanceGroup_Call{Call: _e.mock.On("UpdateNodeInstanceGroup", ctx, nodeSpec, primaryInstance, fallbackInstances)}
}

func (_c *Service_UpdateNodeInstanceGroup_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string, fallbackInstances []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance)) *Service_UpdateNodeInstanceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance
		if args[3] != nil {
			arg3 = args[3].([]*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateNodeInstanceGroup_Call) Return(v *entity.NodeInstanceGroup, err error) *Service_UpdateNodeInstanceGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_UpdateNodeInstanceGroup_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string, fallbackInstances []*cluster_service_ngv1beta.NodeInstanceGroup_FallbackInstance) (*entity.NodeInstanceGroup, error)) *Service_UpdateNodeInstanceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePlacementPolicy provides a mock function for the type Service
func (_mock *Service) UpdatePlacementPolicy(ctx context.Context, sharedPoolId string, placementPolicyId string, tikvGroupId string) (*entity.PlacementPolicy, error) {
	ret := _mock.Called(ctx, sharedPoolId, placementPolicyId, tikvGroupId)

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

	var r0 *entity.PlacementPolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.PlacementPolicy, error)); ok {
		return returnFunc(ctx, sharedPoolId, placementPolicyId, tikvGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.PlacementPolicy); ok {
		r0 = returnFunc(ctx, sharedPoolId, placementPolicyId, tikvGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PlacementPolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, placementPolicyId, tikvGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdatePlacementPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - placementPolicyId string
//   - tikvGroupId string
func (_e *Service_Expecter) UpdatePlacementPolicy(ctx interface{}, sharedPoolId interface{}, placementPolicyId interface{}, tikvGroupId interface{}) *Service_UpdatePlacementPolicy_Call {
	return &Service_UpdatePlacementPolicy_Call{Call: _e.mock.On("UpdatePlacementPolicy", ctx, sharedPoolId, placementPolicyId, tikvGroupId)}
}

func (_c *Service_UpdatePlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, placementPolicyId string, tikvGroupId string)) *Service_UpdatePlacementPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdatePlacementPolicy_Call) Return(v *entity.PlacementPolicy, err error) *Service_UpdatePlacementPolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_UpdatePlacementPolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, placementPolicyId string, tikvGroupId string) (*entity.PlacementPolicy, error)) *Service_UpdatePlacementPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePrivateLinkService provides a mock function for the type Service
func (_mock *Service) UpdatePrivateLinkService(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string, privateLinkConnections []*entity.PrivateLinkConnection) (*entity.PrivateLinkService, error) {
	ret := _mock.Called(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId, privateLinkConnections)

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

	var r0 *entity.PrivateLinkService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []*entity.PrivateLinkConnection) (*entity.PrivateLinkService, error)); ok {
		return returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId, privateLinkConnections)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []*entity.PrivateLinkConnection) *entity.PrivateLinkService); ok {
		r0 = returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId, privateLinkConnections)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PrivateLinkService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, []*entity.PrivateLinkConnection) error); ok {
		r1 = returnFunc(ctx, tidbClusterId, tidbGroupId, privateLinkServiceId, privateLinkConnections)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdatePrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbClusterId string
//   - tidbGroupId string
//   - privateLinkServiceId string
//   - privateLinkConnections []*entity.PrivateLinkConnection
func (_e *Service_Expecter) UpdatePrivateLinkService(ctx interface{}, tidbClusterId interface{}, tidbGroupId interface{}, privateLinkServiceId interface{}, privateLinkConnections interface{}) *Service_UpdatePrivateLinkService_Call {
	return &Service_UpdatePrivateLinkService_Call{Call: _e.mock.On("UpdatePrivateLinkService", ctx, tidbClusterId, tidbGroupId, privateLinkServiceId, privateLinkConnections)}
}

func (_c *Service_UpdatePrivateLinkService_Call) Run(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string, privateLinkConnections []*entity.PrivateLinkConnection)) *Service_UpdatePrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []*entity.PrivateLinkConnection
		if args[4] != nil {
			arg4 = args[4].([]*entity.PrivateLinkConnection)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Service_UpdatePrivateLinkService_Call) Return(v *entity.PrivateLinkService, err error) *Service_UpdatePrivateLinkService_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_UpdatePrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, tidbClusterId string, tidbGroupId string, privateLinkServiceId string, privateLinkConnections []*entity.PrivateLinkConnection) (*entity.PrivateLinkService, error)) *Service_UpdatePrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSharedPoolCloudResourceTags provides a mock function for the type Service
func (_mock *Service) UpdateSharedPoolCloudResourceTags(ctx context.Context, sharedPoolId string, cloudResourceTags map[string]string, removeCloudResourceTagKeys []string) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, cloudResourceTags, removeCloudResourceTagKeys)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, map[string]string, []string) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, cloudResourceTags, removeCloudResourceTagKeys)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, map[string]string, []string) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, cloudResourceTags, removeCloudResourceTagKeys)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, map[string]string, []string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, cloudResourceTags, removeCloudResourceTagKeys)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateSharedPoolCloudResourceTags is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - cloudResourceTags map[string]string
//   - removeCloudResourceTagKeys []string
func (_e *Service_Expecter) UpdateSharedPoolCloudResourceTags(ctx interface{}, sharedPoolId interface{}, cloudResourceTags interface{}, removeCloudResourceTagKeys interface{}) *Service_UpdateSharedPoolCloudResourceTags_Call {
	return &Service_UpdateSharedPoolCloudResourceTags_Call{Call: _e.mock.On("UpdateSharedPoolCloudResourceTags", ctx, sharedPoolId, cloudResourceTags, removeCloudResourceTagKeys)}
}

func (_c *Service_UpdateSharedPoolCloudResourceTags_Call) Run(run func(ctx context.Context, sharedPoolId string, cloudResourceTags map[string]string, removeCloudResourceTagKeys []string)) *Service_UpdateSharedPoolCloudResourceTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 map[string]string
		if args[2] != nil {
			arg2 = args[2].(map[string]string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateSharedPoolCloudResourceTags_Call) Return(sharedPool *entity.SharedPool, err error) *Service_UpdateSharedPoolCloudResourceTags_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_UpdateSharedPoolCloudResourceTags_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, cloudResourceTags map[string]string, removeCloudResourceTagKeys []string) (*entity.SharedPool, error)) *Service_UpdateSharedPoolCloudResourceTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSharedPoolVcpusLimit provides a mock function for the type Service
func (_mock *Service) UpdateSharedPoolVcpusLimit(ctx context.Context, sharedPoolId string, vcpusLimit uint64) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, sharedPoolId, vcpusLimit)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, sharedPoolId, vcpusLimit)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, sharedPoolId, vcpusLimit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, uint64) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, vcpusLimit)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateSharedPoolVcpusLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - vcpusLimit uint64
func (_e *Service_Expecter) UpdateSharedPoolVcpusLimit(ctx interface{}, sharedPoolId interface{}, vcpusLimit interface{}) *Service_UpdateSharedPoolVcpusLimit_Call {
	return &Service_UpdateSharedPoolVcpusLimit_Call{Call: _e.mock.On("UpdateSharedPoolVcpusLimit", ctx, sharedPoolId, vcpusLimit)}
}

func (_c *Service_UpdateSharedPoolVcpusLimit_Call) Run(run func(ctx context.Context, sharedPoolId string, vcpusLimit uint64)) *Service_UpdateSharedPoolVcpusLimit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 uint64
		if args[2] != nil {
			arg2 = args[2].(uint64)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_UpdateSharedPoolVcpusLimit_Call) Return(sharedPool *entity.SharedPool, err error) *Service_UpdateSharedPoolVcpusLimit_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *Service_UpdateSharedPoolVcpusLimit_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, vcpusLimit uint64) (*entity.SharedPool, error)) *Service_UpdateSharedPoolVcpusLimit_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiDBCluster provides a mock function for the type Service
func (_mock *Service) UpdateTiDBCluster(ctx context.Context, tidbCluster *entity.TiDBCluster, force bool) (*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, tidbCluster, force)

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

	var r0 *entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBCluster, bool) (*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, tidbCluster, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBCluster, bool) *entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, tidbCluster, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.TiDBCluster, bool) error); ok {
		r1 = returnFunc(ctx, tidbCluster, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateTiDBCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbCluster *entity.TiDBCluster
//   - force bool
func (_e *Service_Expecter) UpdateTiDBCluster(ctx interface{}, tidbCluster interface{}, force interface{}) *Service_UpdateTiDBCluster_Call {
	return &Service_UpdateTiDBCluster_Call{Call: _e.mock.On("UpdateTiDBCluster", ctx, tidbCluster, force)}
}

func (_c *Service_UpdateTiDBCluster_Call) Run(run func(ctx context.Context, tidbCluster *entity.TiDBCluster, force bool)) *Service_UpdateTiDBCluster_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TiDBCluster
		if args[1] != nil {
			arg1 = args[1].(*entity.TiDBCluster)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_UpdateTiDBCluster_Call) Return(v *entity.TiDBCluster, err error) *Service_UpdateTiDBCluster_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_UpdateTiDBCluster_Call) RunAndReturn(run func(ctx context.Context, tidbCluster *entity.TiDBCluster, force bool) (*entity.TiDBCluster, error)) *Service_UpdateTiDBCluster_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiDBGroup provides a mock function for the type Service
func (_mock *Service) UpdateTiDBGroup(ctx context.Context, tidbGroup *entity.TiDBGroup, force bool) (*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, tidbGroup, force)

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

	var r0 *entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBGroup, bool) (*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, tidbGroup, force)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBGroup, bool) *entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, tidbGroup, force)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.TiDBGroup, bool) error); ok {
		r1 = returnFunc(ctx, tidbGroup, force)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateTiDBGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbGroup *entity.TiDBGroup
//   - force bool
func (_e *Service_Expecter) UpdateTiDBGroup(ctx interface{}, tidbGroup interface{}, force interface{}) *Service_UpdateTiDBGroup_Call {
	return &Service_UpdateTiDBGroup_Call{Call: _e.mock.On("UpdateTiDBGroup", ctx, tidbGroup, force)}
}

func (_c *Service_UpdateTiDBGroup_Call) Run(run func(ctx context.Context, tidbGroup *entity.TiDBGroup, force bool)) *Service_UpdateTiDBGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TiDBGroup
		if args[1] != nil {
			arg1 = args[1].(*entity.TiDBGroup)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_UpdateTiDBGroup_Call) Return(tiDBGroup *entity.TiDBGroup, err error) *Service_UpdateTiDBGroup_Call {
	_c.Call.Return(tiDBGroup, err)
	return _c
}

func (_c *Service_UpdateTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, tidbGroup *entity.TiDBGroup, force bool) (*entity.TiDBGroup, error)) *Service_UpdateTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertAutoscaleRuntimeGuard provides a mock function for the type Service
func (_mock *Service) UpsertAutoscaleRuntimeGuard(ctx context.Context, guard *entity.AutoscaleRuntimeGuard) (*entity.AutoscaleRuntimeGuard, error) {
	ret := _mock.Called(ctx, guard)

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

	var r0 *entity.AutoscaleRuntimeGuard
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.AutoscaleRuntimeGuard) (*entity.AutoscaleRuntimeGuard, error)); ok {
		return returnFunc(ctx, guard)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.AutoscaleRuntimeGuard) *entity.AutoscaleRuntimeGuard); ok {
		r0 = returnFunc(ctx, guard)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscaleRuntimeGuard)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.AutoscaleRuntimeGuard) error); ok {
		r1 = returnFunc(ctx, guard)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpsertAutoscaleRuntimeGuard is a helper method to define mock.On call
//   - ctx context.Context
//   - guard *entity.AutoscaleRuntimeGuard
func (_e *Service_Expecter) UpsertAutoscaleRuntimeGuard(ctx interface{}, guard interface{}) *Service_UpsertAutoscaleRuntimeGuard_Call {
	return &Service_UpsertAutoscaleRuntimeGuard_Call{Call: _e.mock.On("UpsertAutoscaleRuntimeGuard", ctx, guard)}
}

func (_c *Service_UpsertAutoscaleRuntimeGuard_Call) Run(run func(ctx context.Context, guard *entity.AutoscaleRuntimeGuard)) *Service_UpsertAutoscaleRuntimeGuard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.AutoscaleRuntimeGuard
		if args[1] != nil {
			arg1 = args[1].(*entity.AutoscaleRuntimeGuard)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_UpsertAutoscaleRuntimeGuard_Call) Return(v *entity.AutoscaleRuntimeGuard, err error) *Service_UpsertAutoscaleRuntimeGuard_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_UpsertAutoscaleRuntimeGuard_Call) RunAndReturn(run func(ctx context.Context, guard *entity.AutoscaleRuntimeGuard) (*entity.AutoscaleRuntimeGuard, error)) *Service_UpsertAutoscaleRuntimeGuard_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateSharedPoolPause provides a mock function for the type Service
func (_mock *Service) ValidateSharedPoolPause(ctx context.Context, sharedPoolID string) (*entity.ValidateSharedPoolPauseResponse, error) {
	ret := _mock.Called(ctx, sharedPoolID)

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

	var r0 *entity.ValidateSharedPoolPauseResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.ValidateSharedPoolPauseResponse, error)); ok {
		return returnFunc(ctx, sharedPoolID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.ValidateSharedPoolPauseResponse); ok {
		r0 = returnFunc(ctx, sharedPoolID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ValidateSharedPoolPauseResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ValidateSharedPoolPause is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
func (_e *Service_Expecter) ValidateSharedPoolPause(ctx interface{}, sharedPoolID interface{}) *Service_ValidateSharedPoolPause_Call {
	return &Service_ValidateSharedPoolPause_Call{Call: _e.mock.On("ValidateSharedPoolPause", ctx, sharedPoolID)}
}

func (_c *Service_ValidateSharedPoolPause_Call) Run(run func(ctx context.Context, sharedPoolID string)) *Service_ValidateSharedPoolPause_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ValidateSharedPoolPause_Call) Return(v *entity.ValidateSharedPoolPauseResponse, err error) *Service_ValidateSharedPoolPause_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *Service_ValidateSharedPoolPause_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string) (*entity.ValidateSharedPoolPauseResponse, error)) *Service_ValidateSharedPoolPause_Call {
	_c.Call.Return(run)
	return _c
}