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

package mocks

import (
	"context"

	"github.com/pingcap/kvproto/pkg/keyspacepb"
	"github.com/pingcap/kvproto/pkg/metapb"
	mock "github.com/stretchr/testify/mock"
	"github.com/tidbcloud/cluster-service-ng/api/tidbcloud/cluster-agent/v1"
	"github.com/tidbcloud/cluster-service-ng/domain/entity"
	"github.com/tidbcloud/cluster-service-ng/pkg/clustergateway"
	"github.com/tikv/pd/server/apiv2/handlers"
)

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

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

	return mock
}

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

type Client_Expecter struct {
	mock *mock.Mock
}

func (_m *Client) EXPECT() *Client_Expecter {
	return &Client_Expecter{mock: &_m.Mock}
}

// ClusterAgentOpsRestart provides a mock function for the type Client
func (_mock *Client) ClusterAgentOpsRestart(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.RestartReq) error {
	ret := _mock.Called(ctx, sharedPool, request)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, *cluster_agentv1.RestartReq) error); ok {
		r0 = returnFunc(ctx, sharedPool, request)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ClusterAgentOpsRestart is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.RestartReq
func (_e *Client_Expecter) ClusterAgentOpsRestart(ctx interface{}, sharedPool interface{}, request interface{}) *Client_ClusterAgentOpsRestart_Call {
	return &Client_ClusterAgentOpsRestart_Call{Call: _e.mock.On("ClusterAgentOpsRestart", ctx, sharedPool, request)}
}

func (_c *Client_ClusterAgentOpsRestart_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.RestartReq)) *Client_ClusterAgentOpsRestart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.RestartReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.RestartReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *Client_ClusterAgentOpsRestart_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.RestartReq) error) *Client_ClusterAgentOpsRestart_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCopyPackedBackupTask provides a mock function for the type Client
func (_mock *Client) CreateCopyPackedBackupTask(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateCopyPackedBackupTaskRequest) (*clustergateway.TaskResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// CreateCopyPackedBackupTask is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.CreateCopyPackedBackupTaskRequest
func (_e *Client_Expecter) CreateCopyPackedBackupTask(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_CreateCopyPackedBackupTask_Call {
	return &Client_CreateCopyPackedBackupTask_Call{Call: _e.mock.On("CreateCopyPackedBackupTask", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_CreateCopyPackedBackupTask_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateCopyPackedBackupTaskRequest)) *Client_CreateCopyPackedBackupTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.CreateCopyPackedBackupTaskRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.CreateCopyPackedBackupTaskRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_CreateCopyPackedBackupTask_Call) Return(taskResponse *clustergateway.TaskResponse, err error) *Client_CreateCopyPackedBackupTask_Call {
	_c.Call.Return(taskResponse, err)
	return _c
}

func (_c *Client_CreateCopyPackedBackupTask_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateCopyPackedBackupTaskRequest) (*clustergateway.TaskResponse, error)) *Client_CreateCopyPackedBackupTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateKeySpace provides a mock function for the type Client
func (_mock *Client) CreateKeySpace(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, cmekId string, encryptionContext map[string]string) error {
	ret := _mock.Called(ctx, sharedPool, keySpace, cmekId, encryptionContext)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, string, string, map[string]string) error); ok {
		r0 = returnFunc(ctx, sharedPool, keySpace, cmekId, encryptionContext)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateKeySpace is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - keySpace string
//   - cmekId string
//   - encryptionContext map[string]string
func (_e *Client_Expecter) CreateKeySpace(ctx interface{}, sharedPool interface{}, keySpace interface{}, cmekId interface{}, encryptionContext interface{}) *Client_CreateKeySpace_Call {
	return &Client_CreateKeySpace_Call{Call: _e.mock.On("CreateKeySpace", ctx, sharedPool, keySpace, cmekId, encryptionContext)}
}

func (_c *Client_CreateKeySpace_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, cmekId string, encryptionContext map[string]string)) *Client_CreateKeySpace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 map[string]string
		if args[4] != nil {
			arg4 = args[4].(map[string]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *Client_CreateKeySpace_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, cmekId string, encryptionContext map[string]string) error) *Client_CreateKeySpace_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLightweightBackup provides a mock function for the type Client
func (_mock *Client) CreateLightweightBackup(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string) (*clustergateway.CreateLightweightBackupResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName)

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

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

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

// CreateLightweightBackup is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
func (_e *Client_Expecter) CreateLightweightBackup(ctx interface{}, sharedPool interface{}, tibrCRName interface{}) *Client_CreateLightweightBackup_Call {
	return &Client_CreateLightweightBackup_Call{Call: _e.mock.On("CreateLightweightBackup", ctx, sharedPool, tibrCRName)}
}

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

func (_c *Client_CreateLightweightBackup_Call) Return(createLightweightBackupResponse *clustergateway.CreateLightweightBackupResponse, err error) *Client_CreateLightweightBackup_Call {
	_c.Call.Return(createLightweightBackupResponse, err)
	return _c
}

func (_c *Client_CreateLightweightBackup_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string) (*clustergateway.CreateLightweightBackupResponse, error)) *Client_CreateLightweightBackup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLightweightRestore provides a mock function for the type Client
func (_mock *Client) CreateLightweightRestore(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateLightweightRestoreRequest) (*clustergateway.KernelLightweightRestore, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// CreateLightweightRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.CreateLightweightRestoreRequest
func (_e *Client_Expecter) CreateLightweightRestore(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_CreateLightweightRestore_Call {
	return &Client_CreateLightweightRestore_Call{Call: _e.mock.On("CreateLightweightRestore", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_CreateLightweightRestore_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateLightweightRestoreRequest)) *Client_CreateLightweightRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.CreateLightweightRestoreRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.CreateLightweightRestoreRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_CreateLightweightRestore_Call) Return(kernelLightweightRestore *clustergateway.KernelLightweightRestore, err error) *Client_CreateLightweightRestore_Call {
	_c.Call.Return(kernelLightweightRestore, err)
	return _c
}

func (_c *Client_CreateLightweightRestore_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateLightweightRestoreRequest) (*clustergateway.KernelLightweightRestore, error)) *Client_CreateLightweightRestore_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePackBackupTask provides a mock function for the type Client
func (_mock *Client) CreatePackBackupTask(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreatePackBackupTaskRequest) (*clustergateway.TaskResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// CreatePackBackupTask is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.CreatePackBackupTaskRequest
func (_e *Client_Expecter) CreatePackBackupTask(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_CreatePackBackupTask_Call {
	return &Client_CreatePackBackupTask_Call{Call: _e.mock.On("CreatePackBackupTask", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_CreatePackBackupTask_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreatePackBackupTaskRequest)) *Client_CreatePackBackupTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.CreatePackBackupTaskRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.CreatePackBackupTaskRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_CreatePackBackupTask_Call) Return(taskResponse *clustergateway.TaskResponse, err error) *Client_CreatePackBackupTask_Call {
	_c.Call.Return(taskResponse, err)
	return _c
}

func (_c *Client_CreatePackBackupTask_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreatePackBackupTaskRequest) (*clustergateway.TaskResponse, error)) *Client_CreatePackBackupTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRestorePackedBackupTask provides a mock function for the type Client
func (_mock *Client) CreateRestorePackedBackupTask(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateRestorePackedBackupTaskRequest) (*clustergateway.TaskResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// CreateRestorePackedBackupTask is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.CreateRestorePackedBackupTaskRequest
func (_e *Client_Expecter) CreateRestorePackedBackupTask(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_CreateRestorePackedBackupTask_Call {
	return &Client_CreateRestorePackedBackupTask_Call{Call: _e.mock.On("CreateRestorePackedBackupTask", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_CreateRestorePackedBackupTask_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateRestorePackedBackupTaskRequest)) *Client_CreateRestorePackedBackupTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.CreateRestorePackedBackupTaskRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.CreateRestorePackedBackupTaskRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_CreateRestorePackedBackupTask_Call) Return(taskResponse *clustergateway.TaskResponse, err error) *Client_CreateRestorePackedBackupTask_Call {
	_c.Call.Return(taskResponse, err)
	return _c
}

func (_c *Client_CreateRestorePackedBackupTask_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.CreateRestorePackedBackupTaskRequest) (*clustergateway.TaskResponse, error)) *Client_CreateRestorePackedBackupTask_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCloudAdmin provides a mock function for the type Client
func (_mock *Client) DeleteCloudAdmin(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.DeleteCloudAdminReq) (*cluster_agentv1.DeleteCloudAdminResp, error) {
	ret := _mock.Called(ctx, sharedPool, request)

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

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

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

// DeleteCloudAdmin is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.DeleteCloudAdminReq
func (_e *Client_Expecter) DeleteCloudAdmin(ctx interface{}, sharedPool interface{}, request interface{}) *Client_DeleteCloudAdmin_Call {
	return &Client_DeleteCloudAdmin_Call{Call: _e.mock.On("DeleteCloudAdmin", ctx, sharedPool, request)}
}

func (_c *Client_DeleteCloudAdmin_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.DeleteCloudAdminReq)) *Client_DeleteCloudAdmin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.DeleteCloudAdminReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.DeleteCloudAdminReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Client_DeleteCloudAdmin_Call) Return(deleteCloudAdminResp *cluster_agentv1.DeleteCloudAdminResp, err error) *Client_DeleteCloudAdmin_Call {
	_c.Call.Return(deleteCloudAdminResp, err)
	return _c
}

func (_c *Client_DeleteCloudAdmin_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.DeleteCloudAdminReq) (*cluster_agentv1.DeleteCloudAdminResp, error)) *Client_DeleteCloudAdmin_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLightweightRestore provides a mock function for the type Client
func (_mock *Client) DeleteLightweightRestore(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.KernelLightweightRestoreIdentity) error {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, string, *clustergateway.KernelLightweightRestoreIdentity) error); ok {
		r0 = returnFunc(ctx, sharedPool, tibrCRName, request)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteLightweightRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.KernelLightweightRestoreIdentity
func (_e *Client_Expecter) DeleteLightweightRestore(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_DeleteLightweightRestore_Call {
	return &Client_DeleteLightweightRestore_Call{Call: _e.mock.On("DeleteLightweightRestore", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_DeleteLightweightRestore_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.KernelLightweightRestoreIdentity)) *Client_DeleteLightweightRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.KernelLightweightRestoreIdentity
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.KernelLightweightRestoreIdentity)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *Client_DeleteLightweightRestore_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.KernelLightweightRestoreIdentity) error) *Client_DeleteLightweightRestore_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTiBRTask provides a mock function for the type Client
func (_mock *Client) DeleteTiBRTask(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, taskId string) (*clustergateway.TaskResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, taskId)

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

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

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

// DeleteTiBRTask is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - taskId string
func (_e *Client_Expecter) DeleteTiBRTask(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, taskId interface{}) *Client_DeleteTiBRTask_Call {
	return &Client_DeleteTiBRTask_Call{Call: _e.mock.On("DeleteTiBRTask", ctx, sharedPool, tibrCRName, taskId)}
}

func (_c *Client_DeleteTiBRTask_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, taskId string)) *Client_DeleteTiBRTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_DeleteTiBRTask_Call) Return(taskResponse *clustergateway.TaskResponse, err error) *Client_DeleteTiBRTask_Call {
	_c.Call.Return(taskResponse, err)
	return _c
}

func (_c *Client_DeleteTiBRTask_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, taskId string) (*clustergateway.TaskResponse, error)) *Client_DeleteTiBRTask_Call {
	_c.Call.Return(run)
	return _c
}

// FlushWAL provides a mock function for the type Client
func (_mock *Client) FlushWAL(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string) error {
	ret := _mock.Called(ctx, sharedPool, tibrCRName)

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

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

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

// FlushWAL is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
func (_e *Client_Expecter) FlushWAL(ctx interface{}, sharedPool interface{}, tibrCRName interface{}) *Client_FlushWAL_Call {
	return &Client_FlushWAL_Call{Call: _e.mock.On("FlushWAL", ctx, sharedPool, tibrCRName)}
}

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

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

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

// GeneratePlanReplayerFileDownloadURL provides a mock function for the type Client
func (_mock *Client) GeneratePlanReplayerFileDownloadURL(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.GeneratePlanReplayerFileDownloadURLReq) (*cluster_agentv1.GeneratePlanReplayerFileDownloadURLResp, error) {
	ret := _mock.Called(ctx, sharedPool, request)

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

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

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

// GeneratePlanReplayerFileDownloadURL is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.GeneratePlanReplayerFileDownloadURLReq
func (_e *Client_Expecter) GeneratePlanReplayerFileDownloadURL(ctx interface{}, sharedPool interface{}, request interface{}) *Client_GeneratePlanReplayerFileDownloadURL_Call {
	return &Client_GeneratePlanReplayerFileDownloadURL_Call{Call: _e.mock.On("GeneratePlanReplayerFileDownloadURL", ctx, sharedPool, request)}
}

func (_c *Client_GeneratePlanReplayerFileDownloadURL_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.GeneratePlanReplayerFileDownloadURLReq)) *Client_GeneratePlanReplayerFileDownloadURL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.GeneratePlanReplayerFileDownloadURLReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.GeneratePlanReplayerFileDownloadURLReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Client_GeneratePlanReplayerFileDownloadURL_Call) Return(generatePlanReplayerFileDownloadURLResp *cluster_agentv1.GeneratePlanReplayerFileDownloadURLResp, err error) *Client_GeneratePlanReplayerFileDownloadURL_Call {
	_c.Call.Return(generatePlanReplayerFileDownloadURLResp, err)
	return _c
}

func (_c *Client_GeneratePlanReplayerFileDownloadURL_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.GeneratePlanReplayerFileDownloadURLReq) (*cluster_agentv1.GeneratePlanReplayerFileDownloadURLResp, error)) *Client_GeneratePlanReplayerFileDownloadURL_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupStatus provides a mock function for the type Client
func (_mock *Client) GetBackupStatus(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string) (*clustergateway.BackupStatus, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName)

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

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

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

// GetBackupStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
func (_e *Client_Expecter) GetBackupStatus(ctx interface{}, sharedPool interface{}, tibrCRName interface{}) *Client_GetBackupStatus_Call {
	return &Client_GetBackupStatus_Call{Call: _e.mock.On("GetBackupStatus", ctx, sharedPool, tibrCRName)}
}

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

func (_c *Client_GetBackupStatus_Call) Return(backupStatus *clustergateway.BackupStatus, err error) *Client_GetBackupStatus_Call {
	_c.Call.Return(backupStatus, err)
	return _c
}

func (_c *Client_GetBackupStatus_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string) (*clustergateway.BackupStatus, error)) *Client_GetBackupStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetCluster provides a mock function for the type Client
func (_mock *Client) GetCluster(ctx context.Context, sharedPool *entity.SharedPool) (*metapb.Cluster, error) {
	ret := _mock.Called(ctx, sharedPool)

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

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

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

// GetCluster is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
func (_e *Client_Expecter) GetCluster(ctx interface{}, sharedPool interface{}) *Client_GetCluster_Call {
	return &Client_GetCluster_Call{Call: _e.mock.On("GetCluster", ctx, sharedPool)}
}

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

func (_c *Client_GetCluster_Call) Return(cluster *metapb.Cluster, err error) *Client_GetCluster_Call {
	_c.Call.Return(cluster, err)
	return _c
}

func (_c *Client_GetCluster_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool) (*metapb.Cluster, error)) *Client_GetCluster_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterTopology provides a mock function for the type Client
func (_mock *Client) GetClusterTopology(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.GetClusterTopologyReq) (*cluster_agentv1.GetClusterTopologyResp, error) {
	ret := _mock.Called(ctx, sharedPool, request)

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

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

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

// GetClusterTopology is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.GetClusterTopologyReq
func (_e *Client_Expecter) GetClusterTopology(ctx interface{}, sharedPool interface{}, request interface{}) *Client_GetClusterTopology_Call {
	return &Client_GetClusterTopology_Call{Call: _e.mock.On("GetClusterTopology", ctx, sharedPool, request)}
}

func (_c *Client_GetClusterTopology_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.GetClusterTopologyReq)) *Client_GetClusterTopology_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.GetClusterTopologyReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.GetClusterTopologyReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Client_GetClusterTopology_Call) Return(getClusterTopologyResp *cluster_agentv1.GetClusterTopologyResp, err error) *Client_GetClusterTopology_Call {
	_c.Call.Return(getClusterTopologyResp, err)
	return _c
}

func (_c *Client_GetClusterTopology_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.GetClusterTopologyReq) (*cluster_agentv1.GetClusterTopologyResp, error)) *Client_GetClusterTopology_Call {
	_c.Call.Return(run)
	return _c
}

// GetComponentNodeMetrics provides a mock function for the type Client
func (_mock *Client) GetComponentNodeMetrics(ctx context.Context, sharedPool *entity.SharedPool, componentType string, podName string) ([]byte, error) {
	ret := _mock.Called(ctx, sharedPool, componentType, podName)

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

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

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

// GetComponentNodeMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - componentType string
//   - podName string
func (_e *Client_Expecter) GetComponentNodeMetrics(ctx interface{}, sharedPool interface{}, componentType interface{}, podName interface{}) *Client_GetComponentNodeMetrics_Call {
	return &Client_GetComponentNodeMetrics_Call{Call: _e.mock.On("GetComponentNodeMetrics", ctx, sharedPool, componentType, podName)}
}

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

func (_c *Client_GetComponentNodeMetrics_Call) Return(bytes []byte, err error) *Client_GetComponentNodeMetrics_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *Client_GetComponentNodeMetrics_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, componentType string, podName string) ([]byte, error)) *Client_GetComponentNodeMetrics_Call {
	_c.Call.Return(run)
	return _c
}

// GetComponentRawMetrics provides a mock function for the type Client
func (_mock *Client) GetComponentRawMetrics(ctx context.Context, sharedPool *entity.SharedPool, componentType string, podName string) ([]byte, error) {
	ret := _mock.Called(ctx, sharedPool, componentType, podName)

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

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

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

// GetComponentRawMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - componentType string
//   - podName string
func (_e *Client_Expecter) GetComponentRawMetrics(ctx interface{}, sharedPool interface{}, componentType interface{}, podName interface{}) *Client_GetComponentRawMetrics_Call {
	return &Client_GetComponentRawMetrics_Call{Call: _e.mock.On("GetComponentRawMetrics", ctx, sharedPool, componentType, podName)}
}

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

func (_c *Client_GetComponentRawMetrics_Call) Return(bytes []byte, err error) *Client_GetComponentRawMetrics_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *Client_GetComponentRawMetrics_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, componentType string, podName string) ([]byte, error)) *Client_GetComponentRawMetrics_Call {
	_c.Call.Return(run)
	return _c
}

// GetComponentResourceMetrics provides a mock function for the type Client
func (_mock *Client) GetComponentResourceMetrics(ctx context.Context, sharedPool *entity.SharedPool, componentType string, componentId string) (*cluster_agentv1.GetComponentResourceMetricsResp, error) {
	ret := _mock.Called(ctx, sharedPool, componentType, componentId)

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

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

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

// GetComponentResourceMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - componentType string
//   - componentId string
func (_e *Client_Expecter) GetComponentResourceMetrics(ctx interface{}, sharedPool interface{}, componentType interface{}, componentId interface{}) *Client_GetComponentResourceMetrics_Call {
	return &Client_GetComponentResourceMetrics_Call{Call: _e.mock.On("GetComponentResourceMetrics", ctx, sharedPool, componentType, componentId)}
}

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

func (_c *Client_GetComponentResourceMetrics_Call) Return(getComponentResourceMetricsResp *cluster_agentv1.GetComponentResourceMetricsResp, err error) *Client_GetComponentResourceMetrics_Call {
	_c.Call.Return(getComponentResourceMetricsResp, err)
	return _c
}

func (_c *Client_GetComponentResourceMetrics_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, componentType string, componentId string) (*cluster_agentv1.GetComponentResourceMetricsResp, error)) *Client_GetComponentResourceMetrics_Call {
	_c.Call.Return(run)
	return _c
}

// GetExoticBackupInfo provides a mock function for the type Client
func (_mock *Client) GetExoticBackupInfo(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, exoticBackup string) (*clustergateway.ExoticBackupInfo, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, exoticBackup)

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

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

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

// GetExoticBackupInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - exoticBackup string
func (_e *Client_Expecter) GetExoticBackupInfo(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, exoticBackup interface{}) *Client_GetExoticBackupInfo_Call {
	return &Client_GetExoticBackupInfo_Call{Call: _e.mock.On("GetExoticBackupInfo", ctx, sharedPool, tibrCRName, exoticBackup)}
}

func (_c *Client_GetExoticBackupInfo_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, exoticBackup string)) *Client_GetExoticBackupInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_GetExoticBackupInfo_Call) Return(exoticBackupInfo *clustergateway.ExoticBackupInfo, err error) *Client_GetExoticBackupInfo_Call {
	_c.Call.Return(exoticBackupInfo, err)
	return _c
}

func (_c *Client_GetExoticBackupInfo_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, exoticBackup string) (*clustergateway.ExoticBackupInfo, error)) *Client_GetExoticBackupInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeySpace provides a mock function for the type Client
func (_mock *Client) GetKeySpace(ctx context.Context, sharedPool *entity.SharedPool, keySpace string) (*handlers.KeyspaceMeta, error) {
	ret := _mock.Called(ctx, sharedPool, keySpace)

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

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

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

// GetKeySpace is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - keySpace string
func (_e *Client_Expecter) GetKeySpace(ctx interface{}, sharedPool interface{}, keySpace interface{}) *Client_GetKeySpace_Call {
	return &Client_GetKeySpace_Call{Call: _e.mock.On("GetKeySpace", ctx, sharedPool, keySpace)}
}

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

func (_c *Client_GetKeySpace_Call) Return(keyspaceMeta *handlers.KeyspaceMeta, err error) *Client_GetKeySpace_Call {
	_c.Call.Return(keyspaceMeta, err)
	return _c
}

func (_c *Client_GetKeySpace_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string) (*handlers.KeyspaceMeta, error)) *Client_GetKeySpace_Call {
	_c.Call.Return(run)
	return _c
}

// GetLightweightBackup provides a mock function for the type Client
func (_mock *Client) GetLightweightBackup(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.GetLightweightBackupRequest) (*clustergateway.KernelLightweightBackupItem, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// GetLightweightBackup is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.GetLightweightBackupRequest
func (_e *Client_Expecter) GetLightweightBackup(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_GetLightweightBackup_Call {
	return &Client_GetLightweightBackup_Call{Call: _e.mock.On("GetLightweightBackup", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_GetLightweightBackup_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.GetLightweightBackupRequest)) *Client_GetLightweightBackup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.GetLightweightBackupRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.GetLightweightBackupRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_GetLightweightBackup_Call) Return(kernelLightweightBackupItem *clustergateway.KernelLightweightBackupItem, err error) *Client_GetLightweightBackup_Call {
	_c.Call.Return(kernelLightweightBackupItem, err)
	return _c
}

func (_c *Client_GetLightweightBackup_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.GetLightweightBackupRequest) (*clustergateway.KernelLightweightBackupItem, error)) *Client_GetLightweightBackup_Call {
	_c.Call.Return(run)
	return _c
}

// GetLightweightRestore provides a mock function for the type Client
func (_mock *Client) GetLightweightRestore(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.KernelLightweightRestoreIdentity) (*clustergateway.KernelLightweightRestore, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// GetLightweightRestore is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.KernelLightweightRestoreIdentity
func (_e *Client_Expecter) GetLightweightRestore(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_GetLightweightRestore_Call {
	return &Client_GetLightweightRestore_Call{Call: _e.mock.On("GetLightweightRestore", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_GetLightweightRestore_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.KernelLightweightRestoreIdentity)) *Client_GetLightweightRestore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.KernelLightweightRestoreIdentity
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.KernelLightweightRestoreIdentity)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_GetLightweightRestore_Call) Return(kernelLightweightRestore *clustergateway.KernelLightweightRestore, err error) *Client_GetLightweightRestore_Call {
	_c.Call.Return(kernelLightweightRestore, err)
	return _c
}

func (_c *Client_GetLightweightRestore_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.KernelLightweightRestoreIdentity) (*clustergateway.KernelLightweightRestore, error)) *Client_GetLightweightRestore_Call {
	_c.Call.Return(run)
	return _c
}

// GetTiBRTask provides a mock function for the type Client
func (_mock *Client) GetTiBRTask(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, taskId string) (*clustergateway.TaskResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, taskId)

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

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

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

// GetTiBRTask is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - taskId string
func (_e *Client_Expecter) GetTiBRTask(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, taskId interface{}) *Client_GetTiBRTask_Call {
	return &Client_GetTiBRTask_Call{Call: _e.mock.On("GetTiBRTask", ctx, sharedPool, tibrCRName, taskId)}
}

func (_c *Client_GetTiBRTask_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, taskId string)) *Client_GetTiBRTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_GetTiBRTask_Call) Return(taskResponse *clustergateway.TaskResponse, err error) *Client_GetTiBRTask_Call {
	_c.Call.Return(taskResponse, err)
	return _c
}

func (_c *Client_GetTiBRTask_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, taskId string) (*clustergateway.TaskResponse, error)) *Client_GetTiBRTask_Call {
	_c.Call.Return(run)
	return _c
}

// ListActiveDMSourceCount provides a mock function for the type Client
func (_mock *Client) ListActiveDMSourceCount(ctx context.Context, sharedPool *entity.SharedPool, dmClusterID string) (int, error) {
	ret := _mock.Called(ctx, sharedPool, dmClusterID)

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

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

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

// ListActiveDMSourceCount is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - dmClusterID string
func (_e *Client_Expecter) ListActiveDMSourceCount(ctx interface{}, sharedPool interface{}, dmClusterID interface{}) *Client_ListActiveDMSourceCount_Call {
	return &Client_ListActiveDMSourceCount_Call{Call: _e.mock.On("ListActiveDMSourceCount", ctx, sharedPool, dmClusterID)}
}

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

func (_c *Client_ListActiveDMSourceCount_Call) Return(n int, err error) *Client_ListActiveDMSourceCount_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *Client_ListActiveDMSourceCount_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, dmClusterID string) (int, error)) *Client_ListActiveDMSourceCount_Call {
	_c.Call.Return(run)
	return _c
}

// ListKeySpaces provides a mock function for the type Client
func (_mock *Client) ListKeySpaces(ctx context.Context, sharedPool *entity.SharedPool) (*handlers.LoadAllKeyspacesResponse, error) {
	ret := _mock.Called(ctx, sharedPool)

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

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

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

// ListKeySpaces is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
func (_e *Client_Expecter) ListKeySpaces(ctx interface{}, sharedPool interface{}) *Client_ListKeySpaces_Call {
	return &Client_ListKeySpaces_Call{Call: _e.mock.On("ListKeySpaces", ctx, sharedPool)}
}

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

func (_c *Client_ListKeySpaces_Call) Return(loadAllKeyspacesResponse *handlers.LoadAllKeyspacesResponse, err error) *Client_ListKeySpaces_Call {
	_c.Call.Return(loadAllKeyspacesResponse, err)
	return _c
}

func (_c *Client_ListKeySpaces_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool) (*handlers.LoadAllKeyspacesResponse, error)) *Client_ListKeySpaces_Call {
	_c.Call.Return(run)
	return _c
}

// ListLightweightBackups provides a mock function for the type Client
func (_mock *Client) ListLightweightBackups(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.ListLightweightBackupsRequest) (*clustergateway.ListLightweightBackupsResponse, error) {
	ret := _mock.Called(ctx, sharedPool, tibrCRName, request)

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

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

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

// ListLightweightBackups is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - tibrCRName string
//   - request *clustergateway.ListLightweightBackupsRequest
func (_e *Client_Expecter) ListLightweightBackups(ctx interface{}, sharedPool interface{}, tibrCRName interface{}, request interface{}) *Client_ListLightweightBackups_Call {
	return &Client_ListLightweightBackups_Call{Call: _e.mock.On("ListLightweightBackups", ctx, sharedPool, tibrCRName, request)}
}

func (_c *Client_ListLightweightBackups_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.ListLightweightBackupsRequest)) *Client_ListLightweightBackups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.ListLightweightBackupsRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.ListLightweightBackupsRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Client_ListLightweightBackups_Call) Return(listLightweightBackupsResponse *clustergateway.ListLightweightBackupsResponse, err error) *Client_ListLightweightBackups_Call {
	_c.Call.Return(listLightweightBackupsResponse, err)
	return _c
}

func (_c *Client_ListLightweightBackups_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, tibrCRName string, request *clustergateway.ListLightweightBackupsRequest) (*clustergateway.ListLightweightBackupsResponse, error)) *Client_ListLightweightBackups_Call {
	_c.Call.Return(run)
	return _c
}

// ListPlanReplayerFiles provides a mock function for the type Client
func (_mock *Client) ListPlanReplayerFiles(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.ListPlanReplayerFilesReq) (*cluster_agentv1.ListPlanReplayerFilesResp, error) {
	ret := _mock.Called(ctx, sharedPool, request)

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

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

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

// ListPlanReplayerFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.ListPlanReplayerFilesReq
func (_e *Client_Expecter) ListPlanReplayerFiles(ctx interface{}, sharedPool interface{}, request interface{}) *Client_ListPlanReplayerFiles_Call {
	return &Client_ListPlanReplayerFiles_Call{Call: _e.mock.On("ListPlanReplayerFiles", ctx, sharedPool, request)}
}

func (_c *Client_ListPlanReplayerFiles_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.ListPlanReplayerFilesReq)) *Client_ListPlanReplayerFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.ListPlanReplayerFilesReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.ListPlanReplayerFilesReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Client_ListPlanReplayerFiles_Call) Return(listPlanReplayerFilesResp *cluster_agentv1.ListPlanReplayerFilesResp, err error) *Client_ListPlanReplayerFiles_Call {
	_c.Call.Return(listPlanReplayerFilesResp, err)
	return _c
}

func (_c *Client_ListPlanReplayerFiles_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.ListPlanReplayerFilesReq) (*cluster_agentv1.ListPlanReplayerFilesResp, error)) *Client_ListPlanReplayerFiles_Call {
	_c.Call.Return(run)
	return _c
}

// ListPods provides a mock function for the type Client
func (_mock *Client) ListPods(ctx context.Context, sharedPool *entity.SharedPool) (*cluster_agentv1.ListPodsResp, error) {
	ret := _mock.Called(ctx, sharedPool)

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

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

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

// ListPods is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
func (_e *Client_Expecter) ListPods(ctx interface{}, sharedPool interface{}) *Client_ListPods_Call {
	return &Client_ListPods_Call{Call: _e.mock.On("ListPods", ctx, sharedPool)}
}

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

func (_c *Client_ListPods_Call) Return(listPodsResp *cluster_agentv1.ListPodsResp, err error) *Client_ListPods_Call {
	_c.Call.Return(listPodsResp, err)
	return _c
}

func (_c *Client_ListPods_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool) (*cluster_agentv1.ListPodsResp, error)) *Client_ListPods_Call {
	_c.Call.Return(run)
	return _c
}

// MarkTiProxyPodUnhealthyLegacy provides a mock function for the type Client
func (_mock *Client) MarkTiProxyPodUnhealthyLegacy(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq) error {
	ret := _mock.Called(ctx, sharedPool, request)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, *cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq) error); ok {
		r0 = returnFunc(ctx, sharedPool, request)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// MarkTiProxyPodUnhealthyLegacy is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq
func (_e *Client_Expecter) MarkTiProxyPodUnhealthyLegacy(ctx interface{}, sharedPool interface{}, request interface{}) *Client_MarkTiProxyPodUnhealthyLegacy_Call {
	return &Client_MarkTiProxyPodUnhealthyLegacy_Call{Call: _e.mock.On("MarkTiProxyPodUnhealthyLegacy", ctx, sharedPool, request)}
}

func (_c *Client_MarkTiProxyPodUnhealthyLegacy_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq)) *Client_MarkTiProxyPodUnhealthyLegacy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *Client_MarkTiProxyPodUnhealthyLegacy_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.MarkTiProxyPodUnhealthyLegacyReq) error) *Client_MarkTiProxyPodUnhealthyLegacy_Call {
	_c.Call.Return(run)
	return _c
}

// ProbeTiProxyHealthAPI provides a mock function for the type Client
func (_mock *Client) ProbeTiProxyHealthAPI(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.ProbeTiProxyHealthAPIReq) (*cluster_agentv1.ProbeTiProxyHealthAPIResp, error) {
	ret := _mock.Called(ctx, sharedPool, request)

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

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

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

// ProbeTiProxyHealthAPI is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - request *cluster_agentv1.ProbeTiProxyHealthAPIReq
func (_e *Client_Expecter) ProbeTiProxyHealthAPI(ctx interface{}, sharedPool interface{}, request interface{}) *Client_ProbeTiProxyHealthAPI_Call {
	return &Client_ProbeTiProxyHealthAPI_Call{Call: _e.mock.On("ProbeTiProxyHealthAPI", ctx, sharedPool, request)}
}

func (_c *Client_ProbeTiProxyHealthAPI_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.ProbeTiProxyHealthAPIReq)) *Client_ProbeTiProxyHealthAPI_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 *cluster_agentv1.ProbeTiProxyHealthAPIReq
		if args[2] != nil {
			arg2 = args[2].(*cluster_agentv1.ProbeTiProxyHealthAPIReq)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Client_ProbeTiProxyHealthAPI_Call) Return(probeTiProxyHealthAPIResp *cluster_agentv1.ProbeTiProxyHealthAPIResp, err error) *Client_ProbeTiProxyHealthAPI_Call {
	_c.Call.Return(probeTiProxyHealthAPIResp, err)
	return _c
}

func (_c *Client_ProbeTiProxyHealthAPI_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, request *cluster_agentv1.ProbeTiProxyHealthAPIReq) (*cluster_agentv1.ProbeTiProxyHealthAPIResp, error)) *Client_ProbeTiProxyHealthAPI_Call {
	_c.Call.Return(run)
	return _c
}

// SetKeySpaceResourceGroup provides a mock function for the type Client
func (_mock *Client) SetKeySpaceResourceGroup(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, req *clustergateway.RCURequest) error {
	ret := _mock.Called(ctx, sharedPool, keySpace, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, string, *clustergateway.RCURequest) error); ok {
		r0 = returnFunc(ctx, sharedPool, keySpace, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetKeySpaceResourceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - keySpace string
//   - req *clustergateway.RCURequest
func (_e *Client_Expecter) SetKeySpaceResourceGroup(ctx interface{}, sharedPool interface{}, keySpace interface{}, req interface{}) *Client_SetKeySpaceResourceGroup_Call {
	return &Client_SetKeySpaceResourceGroup_Call{Call: _e.mock.On("SetKeySpaceResourceGroup", ctx, sharedPool, keySpace, req)}
}

func (_c *Client_SetKeySpaceResourceGroup_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, req *clustergateway.RCURequest)) *Client_SetKeySpaceResourceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.RCURequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.RCURequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *Client_SetKeySpaceResourceGroup_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, req *clustergateway.RCURequest) error) *Client_SetKeySpaceResourceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// SetKeySpaceRuVersion provides a mock function for the type Client
func (_mock *Client) SetKeySpaceRuVersion(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, req *clustergateway.SetKeyspaceRuVersionRequest) error {
	ret := _mock.Called(ctx, sharedPool, keySpace, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, string, *clustergateway.SetKeyspaceRuVersionRequest) error); ok {
		r0 = returnFunc(ctx, sharedPool, keySpace, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetKeySpaceRuVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - keySpace string
//   - req *clustergateway.SetKeyspaceRuVersionRequest
func (_e *Client_Expecter) SetKeySpaceRuVersion(ctx interface{}, sharedPool interface{}, keySpace interface{}, req interface{}) *Client_SetKeySpaceRuVersion_Call {
	return &Client_SetKeySpaceRuVersion_Call{Call: _e.mock.On("SetKeySpaceRuVersion", ctx, sharedPool, keySpace, req)}
}

func (_c *Client_SetKeySpaceRuVersion_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, req *clustergateway.SetKeyspaceRuVersionRequest)) *Client_SetKeySpaceRuVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *clustergateway.SetKeyspaceRuVersionRequest
		if args[3] != nil {
			arg3 = args[3].(*clustergateway.SetKeyspaceRuVersionRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *Client_SetKeySpaceRuVersion_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, req *clustergateway.SetKeyspaceRuVersionRequest) error) *Client_SetKeySpaceRuVersion_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateKeySpaceState provides a mock function for the type Client
func (_mock *Client) UpdateKeySpaceState(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, state keyspacepb.KeyspaceState) error {
	ret := _mock.Called(ctx, sharedPool, keySpace, state)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool, string, keyspacepb.KeyspaceState) error); ok {
		r0 = returnFunc(ctx, sharedPool, keySpace, state)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateKeySpaceState is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
//   - keySpace string
//   - state keyspacepb.KeyspaceState
func (_e *Client_Expecter) UpdateKeySpaceState(ctx interface{}, sharedPool interface{}, keySpace interface{}, state interface{}) *Client_UpdateKeySpaceState_Call {
	return &Client_UpdateKeySpaceState_Call{Call: _e.mock.On("UpdateKeySpaceState", ctx, sharedPool, keySpace, state)}
}

func (_c *Client_UpdateKeySpaceState_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, state keyspacepb.KeyspaceState)) *Client_UpdateKeySpaceState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 keyspacepb.KeyspaceState
		if args[3] != nil {
			arg3 = args[3].(keyspacepb.KeyspaceState)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *Client_UpdateKeySpaceState_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool, keySpace string, state keyspacepb.KeyspaceState) error) *Client_UpdateKeySpaceState_Call {
	_c.Call.Return(run)
	return _c
}