// Code generated by MockGen. DO NOT EDIT.
// Source: client.go
//
// Generated by this command:
//
//	mockgen -source=client.go -package=mock_regionalserver -imports=v1beta=github.com/tidbcloud/cluster-service-ng/api/cluster-service-ng/v1beta,v1=github.com/tidbcloud/cluster-service-ng/api/tidbcloud/dataplane-manager/v1 -destination=./mock_regionalserver/mock_client.go
//

// Package mock_regionalserver is a generated GoMock package.
package mock_regionalserver

import (
	context "context"
	reflect "reflect"

	v1beta "github.com/tidbcloud/cluster-service-ng/api/cluster-service-ng/v1beta"
	v1 "github.com/tidbcloud/cluster-service-ng/api/tidbcloud/dataplane-manager/v1"
	regionalserver "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/regionalserver"
	entity "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/entity"
	bizerr "github.com/tidbcloud/tidb-management-service/utilities/bizerr"
	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
	isgomock struct{}
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClient) EXPECT() *MockClientMockRecorder {
	return m.recorder
}

// AddEncryptionKeyTrustedDataplane mocks base method.
func (m *MockClient) AddEncryptionKeyTrustedDataplane(ctx context.Context, region *entity.Region, req *v1.AddTrustedDataplaneRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEncryptionKeyTrustedDataplane", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// AddEncryptionKeyTrustedDataplane indicates an expected call of AddEncryptionKeyTrustedDataplane.
func (mr *MockClientMockRecorder) AddEncryptionKeyTrustedDataplane(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEncryptionKeyTrustedDataplane", reflect.TypeOf((*MockClient)(nil).AddEncryptionKeyTrustedDataplane), ctx, region, req)
}

// CancelExport mocks base method.
func (m *MockClient) CancelExport(ctx context.Context, region *entity.Region, req *v1beta.CancelExportRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelExport", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CancelExport indicates an expected call of CancelExport.
func (mr *MockClientMockRecorder) CancelExport(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExport", reflect.TypeOf((*MockClient)(nil).CancelExport), ctx, region, req)
}

// CheckKms mocks base method.
func (m *MockClient) CheckKms(ctx context.Context, region *entity.Region, req *regionalserver.CheckKmsRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckKms", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CheckKms indicates an expected call of CheckKms.
func (mr *MockClientMockRecorder) CheckKms(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckKms", reflect.TypeOf((*MockClient)(nil).CheckKms), ctx, region, req)
}

// CleanExport mocks base method.
func (m *MockClient) CleanExport(ctx context.Context, region *entity.Region, req *v1beta.CancelExportRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanExport", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CleanExport indicates an expected call of CleanExport.
func (mr *MockClientMockRecorder) CleanExport(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanExport", reflect.TypeOf((*MockClient)(nil).CleanExport), ctx, region, req)
}

// CreateAuditLogFilterRuleViaAgent mocks base method.
func (m *MockClient) CreateAuditLogFilterRuleViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.CreateAuditLogFilterRuleViaAgentRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAuditLogFilterRuleViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateAuditLogFilterRuleViaAgent indicates an expected call of CreateAuditLogFilterRuleViaAgent.
func (mr *MockClientMockRecorder) CreateAuditLogFilterRuleViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAuditLogFilterRuleViaAgent", reflect.TypeOf((*MockClient)(nil).CreateAuditLogFilterRuleViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// CreateClassicRestore mocks base method.
func (m *MockClient) CreateClassicRestore(ctx context.Context, region *entity.Region, req *v1beta.CreateClassicRestoreRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClassicRestore", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateClassicRestore indicates an expected call of CreateClassicRestore.
func (mr *MockClientMockRecorder) CreateClassicRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClassicRestore", reflect.TypeOf((*MockClient)(nil).CreateClassicRestore), ctx, region, req)
}

// CreateDefaultEncryptionKey mocks base method.
func (m *MockClient) CreateDefaultEncryptionKey(ctx context.Context, region *entity.Region, req *v1.CreateKeyRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDefaultEncryptionKey", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateDefaultEncryptionKey indicates an expected call of CreateDefaultEncryptionKey.
func (mr *MockClientMockRecorder) CreateDefaultEncryptionKey(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultEncryptionKey", reflect.TypeOf((*MockClient)(nil).CreateDefaultEncryptionKey), ctx, region, req)
}

// CreateExport mocks base method.
func (m *MockClient) CreateExport(ctx context.Context, region *entity.Region, req *v1beta.CreateExportRequest) (*v1beta.Export, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateExport", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.Export)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CreateExport indicates an expected call of CreateExport.
func (mr *MockClientMockRecorder) CreateExport(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExport", reflect.TypeOf((*MockClient)(nil).CreateExport), ctx, region, req)
}

// CreateLightweightRestore mocks base method.
func (m *MockClient) CreateLightweightRestore(ctx context.Context, region *entity.Region, req *v1beta.CreateLightweightRestoreRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLightweightRestore", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateLightweightRestore indicates an expected call of CreateLightweightRestore.
func (mr *MockClientMockRecorder) CreateLightweightRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLightweightRestore", reflect.TypeOf((*MockClient)(nil).CreateLightweightRestore), ctx, region, req)
}

// CreateManualBackup mocks base method.
func (m *MockClient) CreateManualBackup(ctx context.Context, region *entity.Region, req *v1beta.CreateManualBackupRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateManualBackup", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateManualBackup indicates an expected call of CreateManualBackup.
func (mr *MockClientMockRecorder) CreateManualBackup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManualBackup", reflect.TypeOf((*MockClient)(nil).CreateManualBackup), ctx, region, req)
}

// CreateManualBackupRestore mocks base method.
func (m *MockClient) CreateManualBackupRestore(ctx context.Context, region *entity.Region, req *v1beta.CreateManualBackupRestoreRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateManualBackupRestore", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateManualBackupRestore indicates an expected call of CreateManualBackupRestore.
func (mr *MockClientMockRecorder) CreateManualBackupRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManualBackupRestore", reflect.TypeOf((*MockClient)(nil).CreateManualBackupRestore), ctx, region, req)
}

// CreatePrivateLinkService mocks base method.
func (m *MockClient) CreatePrivateLinkService(ctx context.Context, region *entity.Region, req *v1beta.CreatePrivateLinkServiceRequest) (*v1beta.PrivateLinkService, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.PrivateLinkService)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CreatePrivateLinkService indicates an expected call of CreatePrivateLinkService.
func (mr *MockClientMockRecorder) CreatePrivateLinkService(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePrivateLinkService", reflect.TypeOf((*MockClient)(nil).CreatePrivateLinkService), ctx, region, req)
}

// CreateSharedPool mocks base method.
func (m *MockClient) CreateSharedPool(ctx context.Context, region *entity.Region, req *v1beta.CreateSharedPoolRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSharedPool", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CreateSharedPool indicates an expected call of CreateSharedPool.
func (mr *MockClientMockRecorder) CreateSharedPool(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSharedPool", reflect.TypeOf((*MockClient)(nil).CreateSharedPool), ctx, region, req)
}

// CreateTidbCluster mocks base method.
func (m *MockClient) CreateTidbCluster(ctx context.Context, region *entity.Region, req *v1beta.CreateTiDBClusterRequest) (*v1beta.Cluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTidbCluster", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.Cluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CreateTidbCluster indicates an expected call of CreateTidbCluster.
func (mr *MockClientMockRecorder) CreateTidbCluster(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTidbCluster", reflect.TypeOf((*MockClient)(nil).CreateTidbCluster), ctx, region, req)
}

// CreateTidbGroup mocks base method.
func (m *MockClient) CreateTidbGroup(ctx context.Context, region *entity.Region, req *v1beta.CreateTiDBGroupRequest) (*v1beta.TiDBGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.TiDBGroup)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CreateTidbGroup indicates an expected call of CreateTidbGroup.
func (mr *MockClientMockRecorder) CreateTidbGroup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTidbGroup", reflect.TypeOf((*MockClient)(nil).CreateTidbGroup), ctx, region, req)
}

// DeleteAuditLogFilterRuleViaAgent mocks base method.
func (m *MockClient) DeleteAuditLogFilterRuleViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.DeleteAuditLogFilterRuleViaAgentRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAuditLogFilterRuleViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteAuditLogFilterRuleViaAgent indicates an expected call of DeleteAuditLogFilterRuleViaAgent.
func (mr *MockClientMockRecorder) DeleteAuditLogFilterRuleViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAuditLogFilterRuleViaAgent", reflect.TypeOf((*MockClient)(nil).DeleteAuditLogFilterRuleViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// DeleteClassicRestore mocks base method.
func (m *MockClient) DeleteClassicRestore(ctx context.Context, region *entity.Region, req *v1beta.DeleteClassicRestoreRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClassicRestore", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteClassicRestore indicates an expected call of DeleteClassicRestore.
func (mr *MockClientMockRecorder) DeleteClassicRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClassicRestore", reflect.TypeOf((*MockClient)(nil).DeleteClassicRestore), ctx, region, req)
}

// DeleteLightweightRestore mocks base method.
func (m *MockClient) DeleteLightweightRestore(ctx context.Context, region *entity.Region, req *v1beta.DeleteLightweightRestoreRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLightweightRestore", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteLightweightRestore indicates an expected call of DeleteLightweightRestore.
func (mr *MockClientMockRecorder) DeleteLightweightRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLightweightRestore", reflect.TypeOf((*MockClient)(nil).DeleteLightweightRestore), ctx, region, req)
}

// DeleteManualBackup mocks base method.
func (m *MockClient) DeleteManualBackup(ctx context.Context, region *entity.Region, req *v1beta.DeleteManualBackupRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteManualBackup", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteManualBackup indicates an expected call of DeleteManualBackup.
func (mr *MockClientMockRecorder) DeleteManualBackup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManualBackup", reflect.TypeOf((*MockClient)(nil).DeleteManualBackup), ctx, region, req)
}

// DeleteManualBackupRestore mocks base method.
func (m *MockClient) DeleteManualBackupRestore(ctx context.Context, region *entity.Region, req *v1beta.DeleteManualBackupRestoreRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteManualBackupRestore", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteManualBackupRestore indicates an expected call of DeleteManualBackupRestore.
func (mr *MockClientMockRecorder) DeleteManualBackupRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManualBackupRestore", reflect.TypeOf((*MockClient)(nil).DeleteManualBackupRestore), ctx, region, req)
}

// DeletePrivateLinkService mocks base method.
func (m *MockClient) DeletePrivateLinkService(ctx context.Context, region *entity.Region, req *v1beta.DeletePrivateLinkServiceRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeletePrivateLinkService indicates an expected call of DeletePrivateLinkService.
func (mr *MockClientMockRecorder) DeletePrivateLinkService(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePrivateLinkService", reflect.TypeOf((*MockClient)(nil).DeletePrivateLinkService), ctx, region, req)
}

// DeleteSharedPool mocks base method.
func (m *MockClient) DeleteSharedPool(ctx context.Context, region *entity.Region, req *v1beta.DeleteSharedPoolRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSharedPool", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteSharedPool indicates an expected call of DeleteSharedPool.
func (mr *MockClientMockRecorder) DeleteSharedPool(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSharedPool", reflect.TypeOf((*MockClient)(nil).DeleteSharedPool), ctx, region, req)
}

// DeleteTidbCluster mocks base method.
func (m *MockClient) DeleteTidbCluster(ctx context.Context, region *entity.Region, req *v1beta.DeleteTiDBClusterRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTidbCluster", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteTidbCluster indicates an expected call of DeleteTidbCluster.
func (mr *MockClientMockRecorder) DeleteTidbCluster(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTidbCluster", reflect.TypeOf((*MockClient)(nil).DeleteTidbCluster), ctx, region, req)
}

// DeleteTidbGroup mocks base method.
func (m *MockClient) DeleteTidbGroup(ctx context.Context, region *entity.Region, req *v1beta.DeleteTiDBGroupRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteTidbGroup indicates an expected call of DeleteTidbGroup.
func (mr *MockClientMockRecorder) DeleteTidbGroup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTidbGroup", reflect.TypeOf((*MockClient)(nil).DeleteTidbGroup), ctx, region, req)
}

// EvaluateSharedPoolNetworkCapacity mocks base method.
func (m *MockClient) EvaluateSharedPoolNetworkCapacity(ctx context.Context, region *entity.Region, req *v1beta.EvaluateSharedPoolNetworkCapacityRequest) (*v1beta.EvaluateSharedPoolNetworkCapacityResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EvaluateSharedPoolNetworkCapacity", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.EvaluateSharedPoolNetworkCapacityResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// EvaluateSharedPoolNetworkCapacity indicates an expected call of EvaluateSharedPoolNetworkCapacity.
func (mr *MockClientMockRecorder) EvaluateSharedPoolNetworkCapacity(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvaluateSharedPoolNetworkCapacity", reflect.TypeOf((*MockClient)(nil).EvaluateSharedPoolNetworkCapacity), ctx, region, req)
}

// ExecuteClusterAgentCommand mocks base method.
func (m *MockClient) ExecuteClusterAgentCommand(ctx context.Context, region *entity.Region, clusterId, sharedPoolId, command string) (*regionalserver.ExecuteCommandResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteClusterAgentCommand", ctx, region, clusterId, sharedPoolId, command)
	ret0, _ := ret[0].(*regionalserver.ExecuteCommandResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ExecuteClusterAgentCommand indicates an expected call of ExecuteClusterAgentCommand.
func (mr *MockClientMockRecorder) ExecuteClusterAgentCommand(ctx, region, clusterId, sharedPoolId, command any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteClusterAgentCommand", reflect.TypeOf((*MockClient)(nil).ExecuteClusterAgentCommand), ctx, region, clusterId, sharedPoolId, command)
}

// ForceUpdateGatewayIdentity mocks base method.
func (m *MockClient) ForceUpdateGatewayIdentity(ctx context.Context, region *entity.Region, req *v1beta.ForceUpdateGatewayIdentityRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceUpdateGatewayIdentity", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// ForceUpdateGatewayIdentity indicates an expected call of ForceUpdateGatewayIdentity.
func (mr *MockClientMockRecorder) ForceUpdateGatewayIdentity(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateGatewayIdentity", reflect.TypeOf((*MockClient)(nil).ForceUpdateGatewayIdentity), ctx, region, req)
}

// GetBackupGcSetting mocks base method.
func (m *MockClient) GetBackupGcSetting(ctx context.Context, region *entity.Region, req *v1beta.GetBackupGcSettingRequest) (*v1beta.BackupGcSetting, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBackupGcSetting", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.BackupGcSetting)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetBackupGcSetting indicates an expected call of GetBackupGcSetting.
func (mr *MockClientMockRecorder) GetBackupGcSetting(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBackupGcSetting", reflect.TypeOf((*MockClient)(nil).GetBackupGcSetting), ctx, region, req)
}

// GetClassicRestore mocks base method.
func (m *MockClient) GetClassicRestore(ctx context.Context, region *entity.Region, req *v1beta.GetClassicRestoreRequest) (*v1beta.ClassicRestore, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClassicRestore", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ClassicRestore)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetClassicRestore indicates an expected call of GetClassicRestore.
func (mr *MockClientMockRecorder) GetClassicRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClassicRestore", reflect.TypeOf((*MockClient)(nil).GetClassicRestore), ctx, region, req)
}

// GetClusterAgentPublicKey mocks base method.
func (m *MockClient) GetClusterAgentPublicKey(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string) ([]byte, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterAgentPublicKey", ctx, region, clusterId, sharedPoolId)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetClusterAgentPublicKey indicates an expected call of GetClusterAgentPublicKey.
func (mr *MockClientMockRecorder) GetClusterAgentPublicKey(ctx, region, clusterId, sharedPoolId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterAgentPublicKey", reflect.TypeOf((*MockClient)(nil).GetClusterAgentPublicKey), ctx, region, clusterId, sharedPoolId)
}

// GetClusterAgentPublicKeyViaSharedPool mocks base method.
func (m *MockClient) GetClusterAgentPublicKeyViaSharedPool(ctx context.Context, region *entity.Region, sharedPoolId string) ([]byte, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterAgentPublicKeyViaSharedPool", ctx, region, sharedPoolId)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetClusterAgentPublicKeyViaSharedPool indicates an expected call of GetClusterAgentPublicKeyViaSharedPool.
func (mr *MockClientMockRecorder) GetClusterAgentPublicKeyViaSharedPool(ctx, region, sharedPoolId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterAgentPublicKeyViaSharedPool", reflect.TypeOf((*MockClient)(nil).GetClusterAgentPublicKeyViaSharedPool), ctx, region, sharedPoolId)
}

// GetDataPlane mocks base method.
func (m *MockClient) GetDataPlane(ctx context.Context, region *entity.Region, req *v1.GetDataPlaneRequest) (*v1.DataPlane, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDataPlane", ctx, region, req)
	ret0, _ := ret[0].(*v1.DataPlane)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetDataPlane indicates an expected call of GetDataPlane.
func (mr *MockClientMockRecorder) GetDataPlane(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataPlane", reflect.TypeOf((*MockClient)(nil).GetDataPlane), ctx, region, req)
}

// GetDefaultEncryptionKey mocks base method.
func (m *MockClient) GetDefaultEncryptionKey(ctx context.Context, region *entity.Region, req *v1.GetKeyRequest) (*v1.Key, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultEncryptionKey", ctx, region, req)
	ret0, _ := ret[0].(*v1.Key)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetDefaultEncryptionKey indicates an expected call of GetDefaultEncryptionKey.
func (mr *MockClientMockRecorder) GetDefaultEncryptionKey(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultEncryptionKey", reflect.TypeOf((*MockClient)(nil).GetDefaultEncryptionKey), ctx, region, req)
}

// GetEncryptionKeyTrustedDataplane mocks base method.
func (m *MockClient) GetEncryptionKeyTrustedDataplane(ctx context.Context, region *entity.Region, req *v1.GetTrustedDataplaneRequest) (*v1.GetTrustedDataplaneResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEncryptionKeyTrustedDataplane", ctx, region, req)
	ret0, _ := ret[0].(*v1.GetTrustedDataplaneResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetEncryptionKeyTrustedDataplane indicates an expected call of GetEncryptionKeyTrustedDataplane.
func (mr *MockClientMockRecorder) GetEncryptionKeyTrustedDataplane(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEncryptionKeyTrustedDataplane", reflect.TypeOf((*MockClient)(nil).GetEncryptionKeyTrustedDataplane), ctx, region, req)
}

// GetExport mocks base method.
func (m *MockClient) GetExport(ctx context.Context, region *entity.Region, req *v1beta.GetExportRequest) (*v1beta.Export, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExport", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.Export)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetExport indicates an expected call of GetExport.
func (mr *MockClientMockRecorder) GetExport(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExport", reflect.TypeOf((*MockClient)(nil).GetExport), ctx, region, req)
}

// GetLightweightRestore mocks base method.
func (m *MockClient) GetLightweightRestore(ctx context.Context, region *entity.Region, req *v1beta.GetLightweightRestoreRequest) (*v1beta.LightweightRestore, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLightweightRestore", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.LightweightRestore)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetLightweightRestore indicates an expected call of GetLightweightRestore.
func (mr *MockClientMockRecorder) GetLightweightRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLightweightRestore", reflect.TypeOf((*MockClient)(nil).GetLightweightRestore), ctx, region, req)
}

// GetLightweightRestorePostActions mocks base method.
func (m *MockClient) GetLightweightRestorePostActions(ctx context.Context, region *entity.Region, req *v1beta.GetLightweightRestorePostActionsRequest) (*v1beta.GetLightweightRestorePostActionsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLightweightRestorePostActions", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.GetLightweightRestorePostActionsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetLightweightRestorePostActions indicates an expected call of GetLightweightRestorePostActions.
func (mr *MockClientMockRecorder) GetLightweightRestorePostActions(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLightweightRestorePostActions", reflect.TypeOf((*MockClient)(nil).GetLightweightRestorePostActions), ctx, region, req)
}

// GetLogRedactionPolicyViaAgent mocks base method.
func (m *MockClient) GetLogRedactionPolicyViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.GetLogRedactionPolicyViaAgentRequest) (*regionalserver.GetLogRedactionPolicyViaAgentResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogRedactionPolicyViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(*regionalserver.GetLogRedactionPolicyViaAgentResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetLogRedactionPolicyViaAgent indicates an expected call of GetLogRedactionPolicyViaAgent.
func (mr *MockClientMockRecorder) GetLogRedactionPolicyViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogRedactionPolicyViaAgent", reflect.TypeOf((*MockClient)(nil).GetLogRedactionPolicyViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// GetManualBackup mocks base method.
func (m *MockClient) GetManualBackup(ctx context.Context, region *entity.Region, req *v1beta.GetManualBackupRequest) (*v1beta.ManualBackup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManualBackup", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ManualBackup)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetManualBackup indicates an expected call of GetManualBackup.
func (mr *MockClientMockRecorder) GetManualBackup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManualBackup", reflect.TypeOf((*MockClient)(nil).GetManualBackup), ctx, region, req)
}

// GetManualBackupRestore mocks base method.
func (m *MockClient) GetManualBackupRestore(ctx context.Context, region *entity.Region, req *v1beta.GetManualBackupRestoreRequest) (*v1beta.ManualBackupRestore, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManualBackupRestore", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ManualBackupRestore)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetManualBackupRestore indicates an expected call of GetManualBackupRestore.
func (mr *MockClientMockRecorder) GetManualBackupRestore(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManualBackupRestore", reflect.TypeOf((*MockClient)(nil).GetManualBackupRestore), ctx, region, req)
}

// GetManualBackupRestorePostActions mocks base method.
func (m *MockClient) GetManualBackupRestorePostActions(ctx context.Context, region *entity.Region, req *v1beta.GetManualBackupRestorePostActionsRequest) (*v1beta.GetManualBackupRestorePostActionsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManualBackupRestorePostActions", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.GetManualBackupRestorePostActionsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetManualBackupRestorePostActions indicates an expected call of GetManualBackupRestorePostActions.
func (mr *MockClientMockRecorder) GetManualBackupRestorePostActions(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManualBackupRestorePostActions", reflect.TypeOf((*MockClient)(nil).GetManualBackupRestorePostActions), ctx, region, req)
}

// GetPauseResumeOperation mocks base method.
func (m *MockClient) GetPauseResumeOperation(ctx context.Context, region *entity.Region, req *v1beta.GetPauseResumeOperationRequest) (*v1beta.PauseResumeOperation, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPauseResumeOperation", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.PauseResumeOperation)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetPauseResumeOperation indicates an expected call of GetPauseResumeOperation.
func (mr *MockClientMockRecorder) GetPauseResumeOperation(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPauseResumeOperation", reflect.TypeOf((*MockClient)(nil).GetPauseResumeOperation), ctx, region, req)
}

// GetPrivateLinkService mocks base method.
func (m *MockClient) GetPrivateLinkService(ctx context.Context, region *entity.Region, req *v1beta.GetPrivateLinkServiceRequest) (*v1beta.PrivateLinkService, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.PrivateLinkService)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetPrivateLinkService indicates an expected call of GetPrivateLinkService.
func (mr *MockClientMockRecorder) GetPrivateLinkService(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateLinkService", reflect.TypeOf((*MockClient)(nil).GetPrivateLinkService), ctx, region, req)
}

// GetProviderRole mocks base method.
func (m *MockClient) GetProviderRole(ctx context.Context, region *entity.Region, req *v1beta.GetProviderRoleRequest) (*v1beta.ProviderRole, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProviderRole", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ProviderRole)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetProviderRole indicates an expected call of GetProviderRole.
func (mr *MockClientMockRecorder) GetProviderRole(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProviderRole", reflect.TypeOf((*MockClient)(nil).GetProviderRole), ctx, region, req)
}

// GetSharedPool mocks base method.
func (m *MockClient) GetSharedPool(ctx context.Context, region *entity.Region, req *v1beta.GetSharedPoolRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSharedPool", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetSharedPool indicates an expected call of GetSharedPool.
func (mr *MockClientMockRecorder) GetSharedPool(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSharedPool", reflect.TypeOf((*MockClient)(nil).GetSharedPool), ctx, region, req)
}

// GetSharedPoolProvisionConfiguration mocks base method.
func (m *MockClient) GetSharedPoolProvisionConfiguration(ctx context.Context, region *entity.Region, req *v1beta.GetSharedPoolProvisionConfigurationRequest) (*v1beta.SharedPoolProvisionConfiguration, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSharedPoolProvisionConfiguration", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPoolProvisionConfiguration)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetSharedPoolProvisionConfiguration indicates an expected call of GetSharedPoolProvisionConfiguration.
func (mr *MockClientMockRecorder) GetSharedPoolProvisionConfiguration(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSharedPoolProvisionConfiguration", reflect.TypeOf((*MockClient)(nil).GetSharedPoolProvisionConfiguration), ctx, region, req)
}

// GetSharedPoolScaleConstraints mocks base method.
func (m *MockClient) GetSharedPoolScaleConstraints(ctx context.Context, region *entity.Region, req *v1beta.GetSharedPoolScaleConstraintsRequest) (*v1beta.GetSharedPoolScaleConstraintsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSharedPoolScaleConstraints", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.GetSharedPoolScaleConstraintsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetSharedPoolScaleConstraints indicates an expected call of GetSharedPoolScaleConstraints.
func (mr *MockClientMockRecorder) GetSharedPoolScaleConstraints(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSharedPoolScaleConstraints", reflect.TypeOf((*MockClient)(nil).GetSharedPoolScaleConstraints), ctx, region, req)
}

// GetSharedPoolVcpusUsage mocks base method.
func (m *MockClient) GetSharedPoolVcpusUsage(ctx context.Context, region *entity.Region, req *v1beta.GetSharedPoolVcpusUsageRequest) (*v1beta.GetSharedPoolVcpusUsageResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSharedPoolVcpusUsage", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.GetSharedPoolVcpusUsageResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetSharedPoolVcpusUsage indicates an expected call of GetSharedPoolVcpusUsage.
func (mr *MockClientMockRecorder) GetSharedPoolVcpusUsage(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSharedPoolVcpusUsage", reflect.TypeOf((*MockClient)(nil).GetSharedPoolVcpusUsage), ctx, region, req)
}

// GetTidbCluster mocks base method.
func (m *MockClient) GetTidbCluster(ctx context.Context, region *entity.Region, req *v1beta.GetTiDBClusterRequest) (*v1beta.Cluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTidbCluster", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.Cluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetTidbCluster indicates an expected call of GetTidbCluster.
func (mr *MockClientMockRecorder) GetTidbCluster(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTidbCluster", reflect.TypeOf((*MockClient)(nil).GetTidbCluster), ctx, region, req)
}

// GetTidbGroup mocks base method.
func (m *MockClient) GetTidbGroup(ctx context.Context, region *entity.Region, req *v1beta.GetTiDBGroupRequest) (*v1beta.TiDBGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.TiDBGroup)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetTidbGroup indicates an expected call of GetTidbGroup.
func (mr *MockClientMockRecorder) GetTidbGroup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTidbGroup", reflect.TypeOf((*MockClient)(nil).GetTidbGroup), ctx, region, req)
}

// GetVpcPeering mocks base method.
func (m *MockClient) GetVpcPeering(ctx context.Context, region *entity.Region, req *v1.GetVpcPeeringRequest) (*v1.VpcPeering, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpcPeering", ctx, region, req)
	ret0, _ := ret[0].(*v1.VpcPeering)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetVpcPeering indicates an expected call of GetVpcPeering.
func (mr *MockClientMockRecorder) GetVpcPeering(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpcPeering", reflect.TypeOf((*MockClient)(nil).GetVpcPeering), ctx, region, req)
}

// ListLightweightBackups mocks base method.
func (m *MockClient) ListLightweightBackups(ctx context.Context, region *entity.Region, req *v1beta.ListLightweightBackupsRequest) (*v1beta.ListLightweightBackupsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLightweightBackups", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ListLightweightBackupsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListLightweightBackups indicates an expected call of ListLightweightBackups.
func (mr *MockClientMockRecorder) ListLightweightBackups(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLightweightBackups", reflect.TypeOf((*MockClient)(nil).ListLightweightBackups), ctx, region, req)
}

// ListNodeSpecs mocks base method.
func (m *MockClient) ListNodeSpecs(ctx context.Context, region *entity.Region, req *v1beta.ListNodeSpecsRequest) (*v1beta.ListNodeSpecsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodeSpecs", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ListNodeSpecsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListNodeSpecs indicates an expected call of ListNodeSpecs.
func (mr *MockClientMockRecorder) ListNodeSpecs(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodeSpecs", reflect.TypeOf((*MockClient)(nil).ListNodeSpecs), ctx, region, req)
}

// ListSharedPools mocks base method.
func (m *MockClient) ListSharedPools(ctx context.Context, region *entity.Region, req *v1beta.ListSharedPoolsRequest) (*v1beta.ListSharedPoolsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSharedPools", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ListSharedPoolsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListSharedPools indicates an expected call of ListSharedPools.
func (mr *MockClientMockRecorder) ListSharedPools(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSharedPools", reflect.TypeOf((*MockClient)(nil).ListSharedPools), ctx, region, req)
}

// ListVpcPeerings mocks base method.
func (m *MockClient) ListVpcPeerings(ctx context.Context, region *entity.Region, req *v1.ListVpcPeeringsRequest) (*v1.ListVpcPeeringsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVpcPeerings", ctx, region, req)
	ret0, _ := ret[0].(*v1.ListVpcPeeringsResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListVpcPeerings indicates an expected call of ListVpcPeerings.
func (mr *MockClientMockRecorder) ListVpcPeerings(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVpcPeerings", reflect.TypeOf((*MockClient)(nil).ListVpcPeerings), ctx, region, req)
}

// PauseSharedPool mocks base method.
func (m *MockClient) PauseSharedPool(ctx context.Context, region *entity.Region, req *v1beta.PauseSharedPoolRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseSharedPool", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// PauseSharedPool indicates an expected call of PauseSharedPool.
func (mr *MockClientMockRecorder) PauseSharedPool(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseSharedPool", reflect.TypeOf((*MockClient)(nil).PauseSharedPool), ctx, region, req)
}

// ReportAutoBackupMetering mocks base method.
func (m *MockClient) ReportAutoBackupMetering(ctx context.Context, region *entity.Region, req *regionalserver.ReportAutoBackupMeteringRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReportAutoBackupMetering", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// ReportAutoBackupMetering indicates an expected call of ReportAutoBackupMetering.
func (mr *MockClientMockRecorder) ReportAutoBackupMetering(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportAutoBackupMetering", reflect.TypeOf((*MockClient)(nil).ReportAutoBackupMetering), ctx, region, req)
}

// ResumeSharedPool mocks base method.
func (m *MockClient) ResumeSharedPool(ctx context.Context, region *entity.Region, req *v1beta.ResumeSharedPoolRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeSharedPool", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ResumeSharedPool indicates an expected call of ResumeSharedPool.
func (mr *MockClientMockRecorder) ResumeSharedPool(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeSharedPool", reflect.TypeOf((*MockClient)(nil).ResumeSharedPool), ctx, region, req)
}

// ScaleSharedPool mocks base method.
func (m *MockClient) ScaleSharedPool(ctx context.Context, region *entity.Region, req *v1beta.ScaleSharedPoolRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScaleSharedPool", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ScaleSharedPool indicates an expected call of ScaleSharedPool.
func (mr *MockClientMockRecorder) ScaleSharedPool(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleSharedPool", reflect.TypeOf((*MockClient)(nil).ScaleSharedPool), ctx, region, req)
}

// ScaleTiDBGroup mocks base method.
func (m *MockClient) ScaleTiDBGroup(ctx context.Context, region *entity.Region, req *v1beta.ScaleTiDBGroupRequest) (*v1beta.TiDBGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScaleTiDBGroup", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.TiDBGroup)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ScaleTiDBGroup indicates an expected call of ScaleTiDBGroup.
func (mr *MockClientMockRecorder) ScaleTiDBGroup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleTiDBGroup", reflect.TypeOf((*MockClient)(nil).ScaleTiDBGroup), ctx, region, req)
}

// SetAuditLogSetting mocks base method.
func (m *MockClient) SetAuditLogSetting(ctx context.Context, region *entity.Region, req *v1beta.SetAuditLogSettingRequest) (*v1beta.Cluster_AuditLogSetting, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAuditLogSetting", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.Cluster_AuditLogSetting)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// SetAuditLogSetting indicates an expected call of SetAuditLogSetting.
func (mr *MockClientMockRecorder) SetAuditLogSetting(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAuditLogSetting", reflect.TypeOf((*MockClient)(nil).SetAuditLogSetting), ctx, region, req)
}

// SetGlobalCloudStorageURIViaAgent mocks base method.
func (m *MockClient) SetGlobalCloudStorageURIViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.SetGlobalCloudStorageURIViaAgentRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGlobalCloudStorageURIViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// SetGlobalCloudStorageURIViaAgent indicates an expected call of SetGlobalCloudStorageURIViaAgent.
func (mr *MockClientMockRecorder) SetGlobalCloudStorageURIViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGlobalCloudStorageURIViaAgent", reflect.TypeOf((*MockClient)(nil).SetGlobalCloudStorageURIViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// SetKongAuditLogSetting mocks base method.
func (m *MockClient) SetKongAuditLogSetting(ctx context.Context, region *entity.Region, req *v1.SetKongAuditLogSettingRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetKongAuditLogSetting", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// SetKongAuditLogSetting indicates an expected call of SetKongAuditLogSetting.
func (mr *MockClientMockRecorder) SetKongAuditLogSetting(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetKongAuditLogSetting", reflect.TypeOf((*MockClient)(nil).SetKongAuditLogSetting), ctx, region, req)
}

// SetPassword mocks base method.
func (m *MockClient) SetPassword(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.SetPasswordRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPassword", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// SetPassword indicates an expected call of SetPassword.
func (mr *MockClientMockRecorder) SetPassword(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPassword", reflect.TypeOf((*MockClient)(nil).SetPassword), ctx, region, clusterId, sharedPoolId, req)
}

// SetPasswordViaSharedPool mocks base method.
func (m *MockClient) SetPasswordViaSharedPool(ctx context.Context, region *entity.Region, sharedPoolId string, req *regionalserver.SetPasswordRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasswordViaSharedPool", ctx, region, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// SetPasswordViaSharedPool indicates an expected call of SetPasswordViaSharedPool.
func (mr *MockClientMockRecorder) SetPasswordViaSharedPool(ctx, region, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordViaSharedPool", reflect.TypeOf((*MockClient)(nil).SetPasswordViaSharedPool), ctx, region, sharedPoolId, req)
}

// TestClassicBackupAccess mocks base method.
func (m *MockClient) TestClassicBackupAccess(ctx context.Context, region *entity.Region, req *v1beta.TestClassicBackupAccessRequest) (*v1beta.TestClassicBackupAccessResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestClassicBackupAccess", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.TestClassicBackupAccessResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// TestClassicBackupAccess indicates an expected call of TestClassicBackupAccess.
func (mr *MockClientMockRecorder) TestClassicBackupAccess(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestClassicBackupAccess", reflect.TypeOf((*MockClient)(nil).TestClassicBackupAccess), ctx, region, req)
}

// UpdateAuditLogFilterRuleViaAgent mocks base method.
func (m *MockClient) UpdateAuditLogFilterRuleViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.UpdateAuditLogFilterRuleViaAgentRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAuditLogFilterRuleViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateAuditLogFilterRuleViaAgent indicates an expected call of UpdateAuditLogFilterRuleViaAgent.
func (mr *MockClientMockRecorder) UpdateAuditLogFilterRuleViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuditLogFilterRuleViaAgent", reflect.TypeOf((*MockClient)(nil).UpdateAuditLogFilterRuleViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// UpdateAuditLogSettingViaAgent mocks base method.
func (m *MockClient) UpdateAuditLogSettingViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.UpdateAuditLogSettingViaAgentRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAuditLogSettingViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateAuditLogSettingViaAgent indicates an expected call of UpdateAuditLogSettingViaAgent.
func (mr *MockClientMockRecorder) UpdateAuditLogSettingViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuditLogSettingViaAgent", reflect.TypeOf((*MockClient)(nil).UpdateAuditLogSettingViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// UpdateAutoBackupMetering mocks base method.
func (m *MockClient) UpdateAutoBackupMetering(ctx context.Context, region *entity.Region, req *regionalserver.AutoBackupMeteringRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAutoBackupMetering", ctx, region, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateAutoBackupMetering indicates an expected call of UpdateAutoBackupMetering.
func (mr *MockClientMockRecorder) UpdateAutoBackupMetering(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoBackupMetering", reflect.TypeOf((*MockClient)(nil).UpdateAutoBackupMetering), ctx, region, req)
}

// UpdateBackupGcSetting mocks base method.
func (m *MockClient) UpdateBackupGcSetting(ctx context.Context, region *entity.Region, req *v1beta.UpdateBackupGcSettingRequest) (*v1beta.BackupGcSetting, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBackupGcSetting", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.BackupGcSetting)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// UpdateBackupGcSetting indicates an expected call of UpdateBackupGcSetting.
func (mr *MockClientMockRecorder) UpdateBackupGcSetting(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBackupGcSetting", reflect.TypeOf((*MockClient)(nil).UpdateBackupGcSetting), ctx, region, req)
}

// UpdateLogRedactionPolicyViaAgent mocks base method.
func (m *MockClient) UpdateLogRedactionPolicyViaAgent(ctx context.Context, region *entity.Region, clusterId, sharedPoolId string, req *regionalserver.UpdateLogRedactionPolicyViaAgentRequest) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogRedactionPolicyViaAgent", ctx, region, clusterId, sharedPoolId, req)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateLogRedactionPolicyViaAgent indicates an expected call of UpdateLogRedactionPolicyViaAgent.
func (mr *MockClientMockRecorder) UpdateLogRedactionPolicyViaAgent(ctx, region, clusterId, sharedPoolId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogRedactionPolicyViaAgent", reflect.TypeOf((*MockClient)(nil).UpdateLogRedactionPolicyViaAgent), ctx, region, clusterId, sharedPoolId, req)
}

// UpdatePrivateLinkService mocks base method.
func (m *MockClient) UpdatePrivateLinkService(ctx context.Context, region *entity.Region, req *v1beta.UpdatePrivateLinkServiceRequest) (*v1beta.PrivateLinkService, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.PrivateLinkService)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// UpdatePrivateLinkService indicates an expected call of UpdatePrivateLinkService.
func (mr *MockClientMockRecorder) UpdatePrivateLinkService(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrivateLinkService", reflect.TypeOf((*MockClient)(nil).UpdatePrivateLinkService), ctx, region, req)
}

// UpdateSharedPoolCloudResourceTags mocks base method.
func (m *MockClient) UpdateSharedPoolCloudResourceTags(ctx context.Context, region *entity.Region, req *v1beta.UpdateSharedPoolCloudResourceTagsRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSharedPoolCloudResourceTags", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// UpdateSharedPoolCloudResourceTags indicates an expected call of UpdateSharedPoolCloudResourceTags.
func (mr *MockClientMockRecorder) UpdateSharedPoolCloudResourceTags(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSharedPoolCloudResourceTags", reflect.TypeOf((*MockClient)(nil).UpdateSharedPoolCloudResourceTags), ctx, region, req)
}

// UpdateSharedPoolVcpusLimit mocks base method.
func (m *MockClient) UpdateSharedPoolVcpusLimit(ctx context.Context, region *entity.Region, req *v1beta.UpdateSharedPoolVcpusLimitRequest) (*v1beta.SharedPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSharedPoolVcpusLimit", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.SharedPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// UpdateSharedPoolVcpusLimit indicates an expected call of UpdateSharedPoolVcpusLimit.
func (mr *MockClientMockRecorder) UpdateSharedPoolVcpusLimit(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSharedPoolVcpusLimit", reflect.TypeOf((*MockClient)(nil).UpdateSharedPoolVcpusLimit), ctx, region, req)
}

// UpdateTidbCluster mocks base method.
func (m *MockClient) UpdateTidbCluster(ctx context.Context, region *entity.Region, req *v1beta.UpdateTiDBClusterRequest) (*v1beta.Cluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTidbCluster", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.Cluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// UpdateTidbCluster indicates an expected call of UpdateTidbCluster.
func (mr *MockClientMockRecorder) UpdateTidbCluster(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTidbCluster", reflect.TypeOf((*MockClient)(nil).UpdateTidbCluster), ctx, region, req)
}

// UpdateTidbGroup mocks base method.
func (m *MockClient) UpdateTidbGroup(ctx context.Context, region *entity.Region, req *v1beta.UpdateTiDBGroupRequest) (*v1beta.TiDBGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.TiDBGroup)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// UpdateTidbGroup indicates an expected call of UpdateTidbGroup.
func (mr *MockClientMockRecorder) UpdateTidbGroup(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTidbGroup", reflect.TypeOf((*MockClient)(nil).UpdateTidbGroup), ctx, region, req)
}

// ValidateSharedPoolPause mocks base method.
func (m *MockClient) ValidateSharedPoolPause(ctx context.Context, region *entity.Region, req *v1beta.ValidateSharedPoolPauseRequest) (*v1beta.ValidateSharedPoolPauseResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateSharedPoolPause", ctx, region, req)
	ret0, _ := ret[0].(*v1beta.ValidateSharedPoolPauseResponse)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ValidateSharedPoolPause indicates an expected call of ValidateSharedPoolPause.
func (mr *MockClientMockRecorder) ValidateSharedPoolPause(ctx, region, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateSharedPoolPause", reflect.TypeOf((*MockClient)(nil).ValidateSharedPoolPause), ctx, region, req)
}