// Code generated by MockGen. DO NOT EDIT.
// Source: client.go
//
// Generated by this command:
//
//	mockgen -source=client.go -package=mock_regionserver -destination=./mock_regionserver/mock_client.go
//

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

import (
	context "context"
	reflect "reflect"

	cluster_agentv1 "github.com/tidbcloud/infra-provider/api/tidbcloud/cluster-agent/v1"
	cluster_controllerv1 "github.com/tidbcloud/infra-provider/api/tidbcloud/cluster-server/v1"
	dedicatedv1 "github.com/tidbcloud/infra-provider/api/tidbcloud/regional-server/v1"
	regionserver "github.com/tidbcloud/tidb-management-service/dedicated-global-service/domain/adapter/regionserver"
	entity "github.com/tidbcloud/tidb-management-service/dedicated-global-service/domain/entity"
	bizerr "github.com/tidbcloud/tidb-management-service/utilities/bizerr"
	gomock "go.uber.org/mock/gomock"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// CreatePrivateLinkService mocks base method.
func (m *MockClient) CreatePrivateLinkService(ctx context.Context, region *entity.Region, req *dedicatedv1.CreatePrivateLinkServiceRequest) (*dedicatedv1.PrivateLinkService, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(*dedicatedv1.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)
}

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

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

// CreateTidbGroup mocks base method.
func (m *MockClient) CreateTidbGroup(ctx context.Context, region *entity.Region, req *cluster_controllerv1.CreateTidbGroupRequest) (*cluster_controllerv1.TidbGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(*cluster_controllerv1.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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeletePrivateLinkService mocks base method.
func (m *MockClient) DeletePrivateLinkService(ctx context.Context, region *entity.Region, req *regionserver.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)
}

// DeleteTidbGroup mocks base method.
func (m *MockClient) DeleteTidbGroup(ctx context.Context, region *entity.Region, req *cluster_controllerv1.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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetPrivateLinkService mocks base method.
func (m *MockClient) GetPrivateLinkService(ctx context.Context, region *entity.Region, req *regionserver.GetPrivateLinkServiceRequest) (*dedicatedv1.PrivateLinkService, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(*dedicatedv1.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)
}

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

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

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

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

// GetTidbGroup mocks base method.
func (m *MockClient) GetTidbGroup(ctx context.Context, region *entity.Region, req *cluster_controllerv1.GetTidbGroupRequest) (*cluster_controllerv1.TidbGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(*cluster_controllerv1.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)
}

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

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

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

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

// GetVpcPeering mocks base method.
func (m *MockClient) GetVpcPeering(ctx context.Context, region *entity.Region, req *dedicatedv1.GetVpcPeeringRequest) (*dedicatedv1.VpcPeering, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpcPeering", ctx, region, req)
	ret0, _ := ret[0].(*dedicatedv1.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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ListVpcPeerings mocks base method.
func (m *MockClient) ListVpcPeerings(ctx context.Context, region *entity.Region, req *dedicatedv1.ListVpcPeeringsRequest) (*dedicatedv1.ListVpcPeeringsResponse, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVpcPeerings", ctx, region, req)
	ret0, _ := ret[0].(*dedicatedv1.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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetTidbGroupPrivateLinkIPAddressType mocks base method.
func (m *MockClient) SetTidbGroupPrivateLinkIPAddressType(ctx context.Context, region *entity.Region, clusterID, tidbGroupID string, addressType dedicatedv1.PrivateLinkIPAddressType) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTidbGroupPrivateLinkIPAddressType", ctx, region, clusterID, tidbGroupID, addressType)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

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

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

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

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

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

// UpdatePrivateLinkService mocks base method.
func (m *MockClient) UpdatePrivateLinkService(ctx context.Context, region *entity.Region, req *regionserver.UpdatePrivateLinkServiceRequest) (*dedicatedv1.PrivateLinkService, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePrivateLinkService", ctx, region, req)
	ret0, _ := ret[0].(*dedicatedv1.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)
}

// UpdateTidbGroup mocks base method.
func (m *MockClient) UpdateTidbGroup(ctx context.Context, region *entity.Region, req *cluster_controllerv1.UpdateTidbGroupRequest) (*cluster_controllerv1.TidbGroup, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTidbGroup", ctx, region, req)
	ret0, _ := ret[0].(*cluster_controllerv1.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)
}

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

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

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

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

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

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