// 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/domain/entity"
	"github.com/tidbcloud/cluster-service-ng/pkg/tioperator"
)

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

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

	return mock
}

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

type TiOperator_Expecter struct {
	mock *mock.Mock
}

func (_m *TiOperator) EXPECT() *TiOperator_Expecter {
	return &TiOperator_Expecter{mock: &_m.Mock}
}

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

	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, *entity.PlacementPolicy, uint32) (*entity.PlacementPolicy, error)); ok {
		return returnFunc(ctx, sharedPoolId, policy, keyspaceId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.PlacementPolicy, uint32) *entity.PlacementPolicy); ok {
		r0 = returnFunc(ctx, sharedPoolId, policy, keyspaceId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PlacementPolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.PlacementPolicy, uint32) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, policy, keyspaceId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreatePlacementPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - policy *entity.PlacementPolicy
//   - keyspaceId uint32
func (_e *TiOperator_Expecter) CreatePlacementPolicy(ctx interface{}, sharedPoolId interface{}, policy interface{}, keyspaceId interface{}) *TiOperator_CreatePlacementPolicy_Call {
	return &TiOperator_CreatePlacementPolicy_Call{Call: _e.mock.On("CreatePlacementPolicy", ctx, sharedPoolId, policy, keyspaceId)}
}

func (_c *TiOperator_CreatePlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, policy *entity.PlacementPolicy, keyspaceId uint32)) *TiOperator_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 *entity.PlacementPolicy
		if args[2] != nil {
			arg2 = args[2].(*entity.PlacementPolicy)
		}
		var arg3 uint32
		if args[3] != nil {
			arg3 = args[3].(uint32)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *TiOperator_CreatePlacementPolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, policy *entity.PlacementPolicy, keyspaceId uint32) (*entity.PlacementPolicy, error)) *TiOperator_CreatePlacementPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePlacementPolicy provides a mock function for the type TiOperator
func (_mock *TiOperator) 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
}

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

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

func (_c *TiOperator_DeletePlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, placementPolicyId string)) *TiOperator_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 *TiOperator_DeletePlacementPolicy_Call) Return(err error) *TiOperator_DeletePlacementPolicy_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, clusterId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, clusterId)
	} 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, clusterId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *TiOperator_GetCluster_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_GetCluster_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 *TiOperator_GetCluster_Call) Return(sharedPool *entity.SharedPool, err error) *TiOperator_GetCluster_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

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

// GetCoprocessorWorker provides a mock function for the type TiOperator
func (_mock *TiOperator) GetCoprocessorWorker(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetCoprocessorWorker_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetCoprocessorWorker_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 *TiOperator_GetCoprocessorWorker_Call) Return(v *entity.Component, err error) *TiOperator_GetCoprocessorWorker_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetCoprocessorWorker_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetCoprocessorWorker_Call {
	_c.Call.Return(run)
	return _c
}

// GetPDGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) GetPDGroup(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetPDGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetPDGroup_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 *TiOperator_GetPDGroup_Call) Return(v *entity.Component, err error) *TiOperator_GetPDGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetPDGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetPDGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetPlacementPolicy provides a mock function for the type TiOperator
func (_mock *TiOperator) 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
}

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

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

func (_c *TiOperator_GetPlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, placementPolicyId string)) *TiOperator_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 *TiOperator_GetPlacementPolicy_Call) Return(v *entity.PlacementPolicy, err error) *TiOperator_GetPlacementPolicy_Call {
	_c.Call.Return(v, err)
	return _c
}

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

// GetSchedulingGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) GetSchedulingGroup(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetSchedulingGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetSchedulingGroup_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 *TiOperator_GetSchedulingGroup_Call) Return(v *entity.Component, err error) *TiOperator_GetSchedulingGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetSchedulingGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetSchedulingGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetSchemaManager provides a mock function for the type TiOperator
func (_mock *TiOperator) GetSchemaManager(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetSchemaManager_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetSchemaManager_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 *TiOperator_GetSchemaManager_Call) Return(v *entity.Component, err error) *TiOperator_GetSchemaManager_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetSchemaManager_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetSchemaManager_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiDBGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiDBGroup(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiDBGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_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 *TiOperator_GetTiDBGroup_Call) Return(v *entity.Component, err error) *TiOperator_GetTiDBGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiDBWorker provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiDBWorker(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiDBWorker_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTiDBWorker_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 *TiOperator_GetTiDBWorker_Call) Return(v *entity.Component, err error) *TiOperator_GetTiDBWorker_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiDBWorker_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiDBWorker_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiFlashCN provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiFlashCN(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiFlashCN_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTiFlashCN_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 *TiOperator_GetTiFlashCN_Call) Return(v *entity.Component, err error) *TiOperator_GetTiFlashCN_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiFlashCN_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiFlashCN_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiFlashWN provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiFlashWN(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiFlashWN_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTiFlashWN_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 *TiOperator_GetTiFlashWN_Call) Return(v *entity.Component, err error) *TiOperator_GetTiFlashWN_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiFlashWN_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiFlashWN_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiKVGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiKVGroup(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiKVGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTiKVGroup_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 *TiOperator_GetTiKVGroup_Call) Return(v *entity.Component, err error) *TiOperator_GetTiKVGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiKVGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiKVGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiKVWorker provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiKVWorker(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiKVWorker_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTiKVWorker_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 *TiOperator_GetTiKVWorker_Call) Return(v *entity.Component, err error) *TiOperator_GetTiKVWorker_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiKVWorker_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiKVWorker_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiProxyGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTiProxyGroup(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTiProxyGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTiProxyGroup_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 *TiOperator_GetTiProxyGroup_Call) Return(v *entity.Component, err error) *TiOperator_GetTiProxyGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTiProxyGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTiProxyGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetTsoGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) GetTsoGroup(ctx context.Context, clusterId string, groupId string) (*entity.Component, error) {
	ret := _mock.Called(ctx, clusterId, groupId)

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

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

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

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

func (_c *TiOperator_GetTsoGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string)) *TiOperator_GetTsoGroup_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 *TiOperator_GetTsoGroup_Call) Return(v *entity.Component, err error) *TiOperator_GetTsoGroup_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiOperator_GetTsoGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string) (*entity.Component, error)) *TiOperator_GetTsoGroup_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *TiOperator_ListClusters_Call) Run(run func(ctx context.Context)) *TiOperator_ListClusters_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 *TiOperator_ListClusters_Call) Return(sharedPools []*entity.SharedPool, err error) *TiOperator_ListClusters_Call {
	_c.Call.Return(sharedPools, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListCoprocessorWorkers_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListCoprocessorWorkers_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 *TiOperator_ListCoprocessorWorkers_Call) Return(vs []*entity.Component, err error) *TiOperator_ListCoprocessorWorkers_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListPDGroups_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListPDGroups_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 *TiOperator_ListPDGroups_Call) Return(vs []*entity.Component, err error) *TiOperator_ListPDGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

// ListPlacementPolicies provides a mock function for the type TiOperator
func (_mock *TiOperator) 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
}

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

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

func (_c *TiOperator_ListPlacementPolicies_Call) Run(run func(ctx context.Context, sharedPoolId string, tikvGroupId string)) *TiOperator_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 *TiOperator_ListPlacementPolicies_Call) Return(vs []*entity.PlacementPolicy, err error) *TiOperator_ListPlacementPolicies_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListSchedulingGroups_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListSchedulingGroups_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 *TiOperator_ListSchedulingGroups_Call) Return(vs []*entity.Component, err error) *TiOperator_ListSchedulingGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListSchemaManagers_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListSchemaManagers_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 *TiOperator_ListSchemaManagers_Call) Return(vs []*entity.Component, err error) *TiOperator_ListSchemaManagers_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiDBGroups_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_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 *TiOperator_ListTiDBGroups_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiDBGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiDBWorkers_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTiDBWorkers_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 *TiOperator_ListTiDBWorkers_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiDBWorkers_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiFlashCNs_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTiFlashCNs_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 *TiOperator_ListTiFlashCNs_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiFlashCNs_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiFlashWNs_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTiFlashWNs_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 *TiOperator_ListTiFlashWNs_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiFlashWNs_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiKVGroups_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTiKVGroups_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 *TiOperator_ListTiKVGroups_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiKVGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiKVWorkers_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTiKVWorkers_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 *TiOperator_ListTiKVWorkers_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiKVWorkers_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTiProxyGroups_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTiProxyGroups_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 *TiOperator_ListTiProxyGroups_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTiProxyGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

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

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

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

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

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

func (_c *TiOperator_ListTsoGroups_Call) Run(run func(ctx context.Context, clusterId string)) *TiOperator_ListTsoGroups_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 *TiOperator_ListTsoGroups_Call) Return(vs []*entity.Component, err error) *TiOperator_ListTsoGroups_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

// UpdateCoprocessorWorker provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateCoprocessorWorker(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateCoprocessorWorker is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateCoprocessorWorker(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateCoprocessorWorker_Call {
	return &TiOperator_UpdateCoprocessorWorker_Call{Call: _e.mock.On("UpdateCoprocessorWorker",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateCoprocessorWorker_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateCoprocessorWorker_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateCoprocessorWorker_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateCoprocessorWorker_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePDGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdatePDGroup(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdatePDGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdatePDGroup(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdatePDGroup_Call {
	return &TiOperator_UpdatePDGroup_Call{Call: _e.mock.On("UpdatePDGroup",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdatePDGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdatePDGroup_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdatePDGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdatePDGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePlacementPolicy provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdatePlacementPolicy(ctx context.Context, sharedPoolId string, policy *entity.PlacementPolicy, keyspaceId uint32) (*entity.PlacementPolicy, error) {
	ret := _mock.Called(ctx, sharedPoolId, policy, keyspaceId)

	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, *entity.PlacementPolicy, uint32) (*entity.PlacementPolicy, error)); ok {
		return returnFunc(ctx, sharedPoolId, policy, keyspaceId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.PlacementPolicy, uint32) *entity.PlacementPolicy); ok {
		r0 = returnFunc(ctx, sharedPoolId, policy, keyspaceId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PlacementPolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.PlacementPolicy, uint32) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, policy, keyspaceId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdatePlacementPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - policy *entity.PlacementPolicy
//   - keyspaceId uint32
func (_e *TiOperator_Expecter) UpdatePlacementPolicy(ctx interface{}, sharedPoolId interface{}, policy interface{}, keyspaceId interface{}) *TiOperator_UpdatePlacementPolicy_Call {
	return &TiOperator_UpdatePlacementPolicy_Call{Call: _e.mock.On("UpdatePlacementPolicy", ctx, sharedPoolId, policy, keyspaceId)}
}

func (_c *TiOperator_UpdatePlacementPolicy_Call) Run(run func(ctx context.Context, sharedPoolId string, policy *entity.PlacementPolicy, keyspaceId uint32)) *TiOperator_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 *entity.PlacementPolicy
		if args[2] != nil {
			arg2 = args[2].(*entity.PlacementPolicy)
		}
		var arg3 uint32
		if args[3] != nil {
			arg3 = args[3].(uint32)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdatePlacementPolicy_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, policy *entity.PlacementPolicy, keyspaceId uint32) (*entity.PlacementPolicy, error)) *TiOperator_UpdatePlacementPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSchedulingGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateSchedulingGroup(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateSchedulingGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateSchedulingGroup(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateSchedulingGroup_Call {
	return &TiOperator_UpdateSchedulingGroup_Call{Call: _e.mock.On("UpdateSchedulingGroup",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateSchedulingGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateSchedulingGroup_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateSchedulingGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateSchedulingGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSchemaManager provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateSchemaManager(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateSchemaManager is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateSchemaManager(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateSchemaManager_Call {
	return &TiOperator_UpdateSchemaManager_Call{Call: _e.mock.On("UpdateSchemaManager",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateSchemaManager_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateSchemaManager_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateSchemaManager_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateSchemaManager_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiDBGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiDBGroup(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiDBGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiDBGroup(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiDBGroup_Call {
	return &TiOperator_UpdateTiDBGroup_Call{Call: _e.mock.On("UpdateTiDBGroup",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiDBGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiDBGroup_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiDBGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiDBGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiDBWorker provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiDBWorker(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiDBWorker is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiDBWorker(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiDBWorker_Call {
	return &TiOperator_UpdateTiDBWorker_Call{Call: _e.mock.On("UpdateTiDBWorker",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiDBWorker_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiDBWorker_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiDBWorker_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiDBWorker_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiFlashCN provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiFlashCN(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiFlashCN is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiFlashCN(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiFlashCN_Call {
	return &TiOperator_UpdateTiFlashCN_Call{Call: _e.mock.On("UpdateTiFlashCN",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiFlashCN_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiFlashCN_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiFlashCN_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiFlashCN_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiFlashWN provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiFlashWN(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiFlashWN is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiFlashWN(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiFlashWN_Call {
	return &TiOperator_UpdateTiFlashWN_Call{Call: _e.mock.On("UpdateTiFlashWN",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiFlashWN_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiFlashWN_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiFlashWN_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiFlashWN_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiKVGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiKVGroup(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiKVGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiKVGroup(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiKVGroup_Call {
	return &TiOperator_UpdateTiKVGroup_Call{Call: _e.mock.On("UpdateTiKVGroup",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiKVGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiKVGroup_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiKVGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiKVGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiKVWorker provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiKVWorker(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiKVWorker is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiKVWorker(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiKVWorker_Call {
	return &TiOperator_UpdateTiKVWorker_Call{Call: _e.mock.On("UpdateTiKVWorker",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiKVWorker_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiKVWorker_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiKVWorker_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiKVWorker_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTiProxyGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTiProxyGroup(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTiProxyGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTiProxyGroup(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTiProxyGroup_Call {
	return &TiOperator_UpdateTiProxyGroup_Call{Call: _e.mock.On("UpdateTiProxyGroup",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTiProxyGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTiProxyGroup_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTiProxyGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTiProxyGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTsoGroup provides a mock function for the type TiOperator
func (_mock *TiOperator) UpdateTsoGroup(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error) {
	var tmpRet mock.Arguments
	if len(options) > 0 {
		tmpRet = _mock.Called(ctx, clusterId, groupId, options)
	} else {
		tmpRet = _mock.Called(ctx, clusterId, groupId)
	}
	ret := tmpRet

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

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

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

// UpdateTsoGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterId string
//   - groupId string
//   - options ...tioperator.UpdateOption
func (_e *TiOperator_Expecter) UpdateTsoGroup(ctx interface{}, clusterId interface{}, groupId interface{}, options ...interface{}) *TiOperator_UpdateTsoGroup_Call {
	return &TiOperator_UpdateTsoGroup_Call{Call: _e.mock.On("UpdateTsoGroup",
		append([]interface{}{ctx, clusterId, groupId}, options...)...)}
}

func (_c *TiOperator_UpdateTsoGroup_Call) Run(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption)) *TiOperator_UpdateTsoGroup_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 []tioperator.UpdateOption
		var variadicArgs []tioperator.UpdateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]tioperator.UpdateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *TiOperator_UpdateTsoGroup_Call) RunAndReturn(run func(ctx context.Context, clusterId string, groupId string, options ...tioperator.UpdateOption) (*entity.Component, error)) *TiOperator_UpdateTsoGroup_Call {
	_c.Call.Return(run)
	return _c
}