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

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

import (
	context "context"
	reflect "reflect"

	commonv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	dedicatedv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/dedicated/v1"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockDedicatedGlobal is a mock of DedicatedGlobal interface.
type MockDedicatedGlobal struct {
	ctrl     *gomock.Controller
	recorder *MockDedicatedGlobalMockRecorder
	isgomock struct{}
}

// MockDedicatedGlobalMockRecorder is the mock recorder for MockDedicatedGlobal.
type MockDedicatedGlobalMockRecorder struct {
	mock *MockDedicatedGlobal
}

// NewMockDedicatedGlobal creates a new mock instance.
func NewMockDedicatedGlobal(ctrl *gomock.Controller) *MockDedicatedGlobal {
	mock := &MockDedicatedGlobal{ctrl: ctrl}
	mock.recorder = &MockDedicatedGlobalMockRecorder{mock}
	return mock
}

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

// AddSecondaryCidr mocks base method.
func (m *MockDedicatedGlobal) AddSecondaryCidr(ctx context.Context, in *dedicatedv1.AddSecondaryCidrRequest, opts ...grpc.CallOption) (*dedicatedv1.Vpc, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddSecondaryCidr", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Vpc)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddSecondaryCidr indicates an expected call of AddSecondaryCidr.
func (mr *MockDedicatedGlobalMockRecorder) AddSecondaryCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSecondaryCidr", reflect.TypeOf((*MockDedicatedGlobal)(nil).AddSecondaryCidr), varargs...)
}

// ApplyCluster mocks base method.
func (m *MockDedicatedGlobal) ApplyCluster(ctx context.Context, in *dedicatedv1.ApplyClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplyCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyCluster indicates an expected call of ApplyCluster.
func (mr *MockDedicatedGlobalMockRecorder) ApplyCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).ApplyCluster), varargs...)
}

// ApplyGKEHeterogeneousDeploy mocks base method.
func (m *MockDedicatedGlobal) ApplyGKEHeterogeneousDeploy(ctx context.Context, in *dedicatedv1.ApplyGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*dedicatedv1.GKEHeterogeneousDeploy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplyGKEHeterogeneousDeploy", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GKEHeterogeneousDeploy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyGKEHeterogeneousDeploy indicates an expected call of ApplyGKEHeterogeneousDeploy.
func (mr *MockDedicatedGlobalMockRecorder) ApplyGKEHeterogeneousDeploy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyGKEHeterogeneousDeploy", reflect.TypeOf((*MockDedicatedGlobal)(nil).ApplyGKEHeterogeneousDeploy), varargs...)
}

// BatchUpsertInstanceMus mocks base method.
func (m *MockDedicatedGlobal) BatchUpsertInstanceMus(ctx context.Context, in *dedicatedv1.BatchUpsertInstanceMusRequest, opts ...grpc.CallOption) (*dedicatedv1.BatchUpsertInstanceMusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchUpsertInstanceMus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.BatchUpsertInstanceMusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchUpsertInstanceMus indicates an expected call of BatchUpsertInstanceMus.
func (mr *MockDedicatedGlobalMockRecorder) BatchUpsertInstanceMus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpsertInstanceMus", reflect.TypeOf((*MockDedicatedGlobal)(nil).BatchUpsertInstanceMus), varargs...)
}

// BatchUpsertSkus mocks base method.
func (m *MockDedicatedGlobal) BatchUpsertSkus(ctx context.Context, in *dedicatedv1.BatchUpsertSkusRequest, opts ...grpc.CallOption) (*dedicatedv1.BatchUpsertSkusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchUpsertSkus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.BatchUpsertSkusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchUpsertSkus indicates an expected call of BatchUpsertSkus.
func (mr *MockDedicatedGlobalMockRecorder) BatchUpsertSkus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpsertSkus", reflect.TypeOf((*MockDedicatedGlobal)(nil).BatchUpsertSkus), varargs...)
}

// BatchUpsertSpus mocks base method.
func (m *MockDedicatedGlobal) BatchUpsertSpus(ctx context.Context, in *dedicatedv1.BatchUpsertSpusRequest, opts ...grpc.CallOption) (*dedicatedv1.BatchUpsertSpusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchUpsertSpus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.BatchUpsertSpusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchUpsertSpus indicates an expected call of BatchUpsertSpus.
func (mr *MockDedicatedGlobalMockRecorder) BatchUpsertSpus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpsertSpus", reflect.TypeOf((*MockDedicatedGlobal)(nil).BatchUpsertSpus), varargs...)
}

// BatchUpsertStorageMus mocks base method.
func (m *MockDedicatedGlobal) BatchUpsertStorageMus(ctx context.Context, in *dedicatedv1.BatchUpsertStorageMusRequest, opts ...grpc.CallOption) (*dedicatedv1.BatchUpsertStorageMusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchUpsertStorageMus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.BatchUpsertStorageMusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchUpsertStorageMus indicates an expected call of BatchUpsertStorageMus.
func (mr *MockDedicatedGlobalMockRecorder) BatchUpsertStorageMus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpsertStorageMus", reflect.TypeOf((*MockDedicatedGlobal)(nil).BatchUpsertStorageMus), varargs...)
}

// BuildDesiredComponents mocks base method.
func (m *MockDedicatedGlobal) BuildDesiredComponents(ctx context.Context, in *dedicatedv1.BuildDesiredComponentsRequest, opts ...grpc.CallOption) (*dedicatedv1.BuildDesiredComponentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BuildDesiredComponents", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.BuildDesiredComponentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildDesiredComponents indicates an expected call of BuildDesiredComponents.
func (mr *MockDedicatedGlobalMockRecorder) BuildDesiredComponents(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildDesiredComponents", reflect.TypeOf((*MockDedicatedGlobal)(nil).BuildDesiredComponents), varargs...)
}

// CalcClusterFee mocks base method.
func (m *MockDedicatedGlobal) CalcClusterFee(ctx context.Context, in *dedicatedv1.CalcClusterFeeRequest, opts ...grpc.CallOption) (*dedicatedv1.CalcClusterFeeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CalcClusterFee", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CalcClusterFeeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcClusterFee indicates an expected call of CalcClusterFee.
func (mr *MockDedicatedGlobalMockRecorder) CalcClusterFee(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcClusterFee", reflect.TypeOf((*MockDedicatedGlobal)(nil).CalcClusterFee), varargs...)
}

// CancelPrivateLinkServiceMigration mocks base method.
func (m *MockDedicatedGlobal) CancelPrivateLinkServiceMigration(ctx context.Context, in *dedicatedv1.CancelPrivateLinkServiceMigrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelPrivateLinkServiceMigration", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelPrivateLinkServiceMigration indicates an expected call of CancelPrivateLinkServiceMigration.
func (mr *MockDedicatedGlobalMockRecorder) CancelPrivateLinkServiceMigration(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelPrivateLinkServiceMigration", reflect.TypeOf((*MockDedicatedGlobal)(nil).CancelPrivateLinkServiceMigration), varargs...)
}

// ChangeClusterPasswd mocks base method.
func (m *MockDedicatedGlobal) ChangeClusterPasswd(ctx context.Context, in *dedicatedv1.ChangeClusterPasswdRequest, opts ...grpc.CallOption) (*dedicatedv1.ChangeClusterPasswdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeClusterPasswd", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ChangeClusterPasswdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeClusterPasswd indicates an expected call of ChangeClusterPasswd.
func (mr *MockDedicatedGlobalMockRecorder) ChangeClusterPasswd(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeClusterPasswd", reflect.TypeOf((*MockDedicatedGlobal)(nil).ChangeClusterPasswd), varargs...)
}

// CheckRegionStatus mocks base method.
func (m *MockDedicatedGlobal) CheckRegionStatus(ctx context.Context, in *dedicatedv1.CheckRegionStatusRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckRegionStatus", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckRegionStatus indicates an expected call of CheckRegionStatus.
func (mr *MockDedicatedGlobalMockRecorder) CheckRegionStatus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRegionStatus", reflect.TypeOf((*MockDedicatedGlobal)(nil).CheckRegionStatus), varargs...)
}

// CreateAuditLogFilterRule mocks base method.
func (m *MockDedicatedGlobal) CreateAuditLogFilterRule(ctx context.Context, in *dedicatedv1.CreateAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*dedicatedv1.AuditLogFilterRule, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAuditLogFilterRule", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.AuditLogFilterRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAuditLogFilterRule indicates an expected call of CreateAuditLogFilterRule.
func (mr *MockDedicatedGlobalMockRecorder) CreateAuditLogFilterRule(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAuditLogFilterRule", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateAuditLogFilterRule), varargs...)
}

// CreateCidr mocks base method.
func (m *MockDedicatedGlobal) CreateCidr(ctx context.Context, in *dedicatedv1.CreateCidrRequest, opts ...grpc.CallOption) (*dedicatedv1.CreateCidrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCidr", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CreateCidrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCidr indicates an expected call of CreateCidr.
func (mr *MockDedicatedGlobalMockRecorder) CreateCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCidr", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateCidr), varargs...)
}

// CreateCluster mocks base method.
func (m *MockDedicatedGlobal) CreateCluster(ctx context.Context, in *dedicatedv1.CreateClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster.
func (mr *MockDedicatedGlobalMockRecorder) CreateCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateCluster), varargs...)
}

// CreateClusterSnapshot mocks base method.
func (m *MockDedicatedGlobal) CreateClusterSnapshot(ctx context.Context, in *dedicatedv1.CreateClusterSnapshotRequest, opts ...grpc.CallOption) (*dedicatedv1.CreateClusterSnapshotResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateClusterSnapshot", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CreateClusterSnapshotResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClusterSnapshot indicates an expected call of CreateClusterSnapshot.
func (mr *MockDedicatedGlobalMockRecorder) CreateClusterSnapshot(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterSnapshot", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateClusterSnapshot), varargs...)
}

// CreateCustomerManagedEncryptionKey mocks base method.
func (m *MockDedicatedGlobal) CreateCustomerManagedEncryptionKey(ctx context.Context, in *dedicatedv1.CreateCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*dedicatedv1.CustomerManagedEncryptionKey, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCustomerManagedEncryptionKey", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CustomerManagedEncryptionKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCustomerManagedEncryptionKey indicates an expected call of CreateCustomerManagedEncryptionKey.
func (mr *MockDedicatedGlobalMockRecorder) CreateCustomerManagedEncryptionKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerManagedEncryptionKey", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateCustomerManagedEncryptionKey), varargs...)
}

// CreatePrivateLinkEndpoint mocks base method.
func (m *MockDedicatedGlobal) CreatePrivateLinkEndpoint(ctx context.Context, in *dedicatedv1.CreatePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*dedicatedv1.CreatePrivateLinkEndpointResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePrivateLinkEndpoint", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CreatePrivateLinkEndpointResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePrivateLinkEndpoint indicates an expected call of CreatePrivateLinkEndpoint.
func (mr *MockDedicatedGlobalMockRecorder) CreatePrivateLinkEndpoint(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePrivateLinkEndpoint", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreatePrivateLinkEndpoint), varargs...)
}

// CreatePrivateLinkService mocks base method.
func (m *MockDedicatedGlobal) CreatePrivateLinkService(ctx context.Context, in *dedicatedv1.CreatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.CreatePrivateLinkServiceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePrivateLinkService", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CreatePrivateLinkServiceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePrivateLinkService indicates an expected call of CreatePrivateLinkService.
func (mr *MockDedicatedGlobalMockRecorder) CreatePrivateLinkService(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePrivateLinkService", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreatePrivateLinkService), varargs...)
}

// CreatePrivateLinkServiceMigration mocks base method.
func (m *MockDedicatedGlobal) CreatePrivateLinkServiceMigration(ctx context.Context, in *dedicatedv1.CreatePrivateLinkServiceMigrationRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkServiceMigration, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePrivateLinkServiceMigration", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.PrivateLinkServiceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePrivateLinkServiceMigration indicates an expected call of CreatePrivateLinkServiceMigration.
func (mr *MockDedicatedGlobalMockRecorder) CreatePrivateLinkServiceMigration(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePrivateLinkServiceMigration", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreatePrivateLinkServiceMigration), varargs...)
}

// CreateTidbNodeGroup mocks base method.
func (m *MockDedicatedGlobal) CreateTidbNodeGroup(ctx context.Context, in *dedicatedv1.CreateTidbNodeGroupRequest, opts ...grpc.CallOption) (*dedicatedv1.TidbNodeGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTidbNodeGroup", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.TidbNodeGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTidbNodeGroup indicates an expected call of CreateTidbNodeGroup.
func (mr *MockDedicatedGlobalMockRecorder) CreateTidbNodeGroup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTidbNodeGroup", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateTidbNodeGroup), varargs...)
}

// CreateVpcPeering mocks base method.
func (m *MockDedicatedGlobal) CreateVpcPeering(ctx context.Context, in *dedicatedv1.CreateVpcPeeringRequest, opts ...grpc.CallOption) (*dedicatedv1.CreateVpcPeeringResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcPeering", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CreateVpcPeeringResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpcPeering indicates an expected call of CreateVpcPeering.
func (mr *MockDedicatedGlobalMockRecorder) CreateVpcPeering(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeering", reflect.TypeOf((*MockDedicatedGlobal)(nil).CreateVpcPeering), varargs...)
}

// DeleteAuditLogFilterRule mocks base method.
func (m *MockDedicatedGlobal) DeleteAuditLogFilterRule(ctx context.Context, in *dedicatedv1.DeleteAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAuditLogFilterRule", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAuditLogFilterRule indicates an expected call of DeleteAuditLogFilterRule.
func (mr *MockDedicatedGlobalMockRecorder) DeleteAuditLogFilterRule(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAuditLogFilterRule", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteAuditLogFilterRule), varargs...)
}

// DeleteCidr mocks base method.
func (m *MockDedicatedGlobal) DeleteCidr(ctx context.Context, in *dedicatedv1.DeleteCidrRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCidr", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCidr indicates an expected call of DeleteCidr.
func (mr *MockDedicatedGlobalMockRecorder) DeleteCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCidr", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteCidr), varargs...)
}

// DeleteCluster mocks base method.
func (m *MockDedicatedGlobal) DeleteCluster(ctx context.Context, in *dedicatedv1.DeleteClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCluster indicates an expected call of DeleteCluster.
func (mr *MockDedicatedGlobalMockRecorder) DeleteCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteCluster), varargs...)
}

// DeleteCustomerManagedEncryptionKey mocks base method.
func (m *MockDedicatedGlobal) DeleteCustomerManagedEncryptionKey(ctx context.Context, in *dedicatedv1.DeleteCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCustomerManagedEncryptionKey", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCustomerManagedEncryptionKey indicates an expected call of DeleteCustomerManagedEncryptionKey.
func (mr *MockDedicatedGlobalMockRecorder) DeleteCustomerManagedEncryptionKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerManagedEncryptionKey", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteCustomerManagedEncryptionKey), varargs...)
}

// DeleteGKEHeterogeneousDeploy mocks base method.
func (m *MockDedicatedGlobal) DeleteGKEHeterogeneousDeploy(ctx context.Context, in *dedicatedv1.DeleteGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteGKEHeterogeneousDeploy", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGKEHeterogeneousDeploy indicates an expected call of DeleteGKEHeterogeneousDeploy.
func (mr *MockDedicatedGlobalMockRecorder) DeleteGKEHeterogeneousDeploy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGKEHeterogeneousDeploy", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteGKEHeterogeneousDeploy), varargs...)
}

// DeletePrivateLinkEndpoint mocks base method.
func (m *MockDedicatedGlobal) DeletePrivateLinkEndpoint(ctx context.Context, in *dedicatedv1.DeletePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePrivateLinkEndpoint", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePrivateLinkEndpoint indicates an expected call of DeletePrivateLinkEndpoint.
func (mr *MockDedicatedGlobalMockRecorder) DeletePrivateLinkEndpoint(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePrivateLinkEndpoint", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeletePrivateLinkEndpoint), varargs...)
}

// DeletePrivateLinkService mocks base method.
func (m *MockDedicatedGlobal) DeletePrivateLinkService(ctx context.Context, in *dedicatedv1.DeletePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePrivateLinkService", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePrivateLinkService indicates an expected call of DeletePrivateLinkService.
func (mr *MockDedicatedGlobalMockRecorder) DeletePrivateLinkService(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePrivateLinkService", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeletePrivateLinkService), varargs...)
}

// DeleteRegion mocks base method.
func (m *MockDedicatedGlobal) DeleteRegion(ctx context.Context, in *dedicatedv1.DeleteRegionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRegion", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRegion indicates an expected call of DeleteRegion.
func (mr *MockDedicatedGlobalMockRecorder) DeleteRegion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegion", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteRegion), varargs...)
}

// DeleteTidbNodeGroup mocks base method.
func (m *MockDedicatedGlobal) DeleteTidbNodeGroup(ctx context.Context, in *dedicatedv1.DeleteTidbNodeGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTidbNodeGroup", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTidbNodeGroup indicates an expected call of DeleteTidbNodeGroup.
func (mr *MockDedicatedGlobalMockRecorder) DeleteTidbNodeGroup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTidbNodeGroup", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteTidbNodeGroup), varargs...)
}

// DeleteVpc mocks base method.
func (m *MockDedicatedGlobal) DeleteVpc(ctx context.Context, in *dedicatedv1.DeleteVpcRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpc", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpc indicates an expected call of DeleteVpc.
func (mr *MockDedicatedGlobalMockRecorder) DeleteVpc(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteVpc), varargs...)
}

// DeleteVpcPeering mocks base method.
func (m *MockDedicatedGlobal) DeleteVpcPeering(ctx context.Context, in *dedicatedv1.DeleteVpcPeeringRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcPeering", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpcPeering indicates an expected call of DeleteVpcPeering.
func (mr *MockDedicatedGlobalMockRecorder) DeleteVpcPeering(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeering", reflect.TypeOf((*MockDedicatedGlobal)(nil).DeleteVpcPeering), varargs...)
}

// DisableClusterConfigBackup mocks base method.
func (m *MockDedicatedGlobal) DisableClusterConfigBackup(ctx context.Context, in *dedicatedv1.DisableClusterConfigBackupRequest, opts ...grpc.CallOption) (*dedicatedv1.ClusterConfigBackupPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableClusterConfigBackup", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ClusterConfigBackupPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableClusterConfigBackup indicates an expected call of DisableClusterConfigBackup.
func (mr *MockDedicatedGlobalMockRecorder) DisableClusterConfigBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableClusterConfigBackup", reflect.TypeOf((*MockDedicatedGlobal)(nil).DisableClusterConfigBackup), varargs...)
}

// DisableTidbGroupDNS mocks base method.
func (m *MockDedicatedGlobal) DisableTidbGroupDNS(ctx context.Context, in *dedicatedv1.DisableTidbGroupDNSRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableTidbGroupDNS", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableTidbGroupDNS indicates an expected call of DisableTidbGroupDNS.
func (mr *MockDedicatedGlobalMockRecorder) DisableTidbGroupDNS(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTidbGroupDNS", reflect.TypeOf((*MockDedicatedGlobal)(nil).DisableTidbGroupDNS), varargs...)
}

// EnableClusterConfigBackup mocks base method.
func (m *MockDedicatedGlobal) EnableClusterConfigBackup(ctx context.Context, in *dedicatedv1.EnableClusterConfigBackupRequest, opts ...grpc.CallOption) (*dedicatedv1.ClusterConfigBackupPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableClusterConfigBackup", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ClusterConfigBackupPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableClusterConfigBackup indicates an expected call of EnableClusterConfigBackup.
func (mr *MockDedicatedGlobalMockRecorder) EnableClusterConfigBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableClusterConfigBackup", reflect.TypeOf((*MockDedicatedGlobal)(nil).EnableClusterConfigBackup), varargs...)
}

// EnableTidbGroupDNS mocks base method.
func (m *MockDedicatedGlobal) EnableTidbGroupDNS(ctx context.Context, in *dedicatedv1.EnableTidbGroupDNSRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableTidbGroupDNS", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableTidbGroupDNS indicates an expected call of EnableTidbGroupDNS.
func (mr *MockDedicatedGlobalMockRecorder) EnableTidbGroupDNS(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTidbGroupDNS", reflect.TypeOf((*MockDedicatedGlobal)(nil).EnableTidbGroupDNS), varargs...)
}

// GenerateAuditLogFileDownloadAddress mocks base method.
func (m *MockDedicatedGlobal) GenerateAuditLogFileDownloadAddress(ctx context.Context, in *dedicatedv1.GenerateAuditLogFileDownloadAddressRequest, opts ...grpc.CallOption) (*dedicatedv1.GenerateAuditLogFileDownloadAddressResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateAuditLogFileDownloadAddress", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GenerateAuditLogFileDownloadAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateAuditLogFileDownloadAddress indicates an expected call of GenerateAuditLogFileDownloadAddress.
func (mr *MockDedicatedGlobalMockRecorder) GenerateAuditLogFileDownloadAddress(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateAuditLogFileDownloadAddress", reflect.TypeOf((*MockDedicatedGlobal)(nil).GenerateAuditLogFileDownloadAddress), varargs...)
}

// GetAccount mocks base method.
func (m *MockDedicatedGlobal) GetAccount(ctx context.Context, in *dedicatedv1.GetAccountRequest, opts ...grpc.CallOption) (*dedicatedv1.GetAccountResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAccount", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetAccountResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccount indicates an expected call of GetAccount.
func (mr *MockDedicatedGlobalMockRecorder) GetAccount(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetAccount), varargs...)
}

// GetAuditLogConfig mocks base method.
func (m *MockDedicatedGlobal) GetAuditLogConfig(ctx context.Context, in *dedicatedv1.GetAuditLogConfigRequest, opts ...grpc.CallOption) (*dedicatedv1.AuditLogConfig, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuditLogConfig", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.AuditLogConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuditLogConfig indicates an expected call of GetAuditLogConfig.
func (mr *MockDedicatedGlobalMockRecorder) GetAuditLogConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuditLogConfig", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetAuditLogConfig), varargs...)
}

// GetBillableClustersCount mocks base method.
func (m *MockDedicatedGlobal) GetBillableClustersCount(ctx context.Context, in *dedicatedv1.GetBillableClustersCountRequest, opts ...grpc.CallOption) (*dedicatedv1.GetBillableClustersCountResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBillableClustersCount", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetBillableClustersCountResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBillableClustersCount indicates an expected call of GetBillableClustersCount.
func (mr *MockDedicatedGlobalMockRecorder) GetBillableClustersCount(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBillableClustersCount", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetBillableClustersCount), varargs...)
}

// GetClientCaCertificate mocks base method.
func (m *MockDedicatedGlobal) GetClientCaCertificate(ctx context.Context, in *dedicatedv1.GetClientCaCertificateRequest, opts ...grpc.CallOption) (*dedicatedv1.GetClientCaCertificateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClientCaCertificate", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetClientCaCertificateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClientCaCertificate indicates an expected call of GetClientCaCertificate.
func (mr *MockDedicatedGlobalMockRecorder) GetClientCaCertificate(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientCaCertificate", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetClientCaCertificate), varargs...)
}

// GetCluster mocks base method.
func (m *MockDedicatedGlobal) GetCluster(ctx context.Context, in *dedicatedv1.GetClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCluster indicates an expected call of GetCluster.
func (mr *MockDedicatedGlobalMockRecorder) GetCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetCluster), varargs...)
}

// GetClusterConfidentialInfo mocks base method.
func (m *MockDedicatedGlobal) GetClusterConfidentialInfo(ctx context.Context, in *dedicatedv1.GetClusterConfidentialInfoRequest, opts ...grpc.CallOption) (*dedicatedv1.GetClusterConfidentialInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterConfidentialInfo", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetClusterConfidentialInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterConfidentialInfo indicates an expected call of GetClusterConfidentialInfo.
func (mr *MockDedicatedGlobalMockRecorder) GetClusterConfidentialInfo(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterConfidentialInfo", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetClusterConfidentialInfo), varargs...)
}

// GetClusterCustomParams mocks base method.
func (m *MockDedicatedGlobal) GetClusterCustomParams(ctx context.Context, in *dedicatedv1.GetClusterCustomParamsRequest, opts ...grpc.CallOption) (*dedicatedv1.GetClusterCustomParamsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterCustomParams", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetClusterCustomParamsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterCustomParams indicates an expected call of GetClusterCustomParams.
func (mr *MockDedicatedGlobalMockRecorder) GetClusterCustomParams(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterCustomParams", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetClusterCustomParams), varargs...)
}

// GetCmekAccessIamPrincipal mocks base method.
func (m *MockDedicatedGlobal) GetCmekAccessIamPrincipal(ctx context.Context, in *dedicatedv1.GetCmekAccessIamPrincipalRequest, opts ...grpc.CallOption) (*dedicatedv1.GetCmekAccessIamPrincipalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCmekAccessIamPrincipal", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetCmekAccessIamPrincipalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCmekAccessIamPrincipal indicates an expected call of GetCmekAccessIamPrincipal.
func (mr *MockDedicatedGlobalMockRecorder) GetCmekAccessIamPrincipal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCmekAccessIamPrincipal", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetCmekAccessIamPrincipal), varargs...)
}

// GetCompatCluster mocks base method.
func (m *MockDedicatedGlobal) GetCompatCluster(ctx context.Context, in *dedicatedv1.GetCompatClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.CompatCluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCompatCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CompatCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCompatCluster indicates an expected call of GetCompatCluster.
func (mr *MockDedicatedGlobalMockRecorder) GetCompatCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompatCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetCompatCluster), varargs...)
}

// GetCompatNetwork mocks base method.
func (m *MockDedicatedGlobal) GetCompatNetwork(ctx context.Context, in *dedicatedv1.GetCompatNetworkRequest, opts ...grpc.CallOption) (*dedicatedv1.CompatNetwork, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCompatNetwork", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CompatNetwork)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCompatNetwork indicates an expected call of GetCompatNetwork.
func (mr *MockDedicatedGlobalMockRecorder) GetCompatNetwork(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompatNetwork", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetCompatNetwork), varargs...)
}

// GetCompatProvider mocks base method.
func (m *MockDedicatedGlobal) GetCompatProvider(ctx context.Context, in *dedicatedv1.GetCompatProviderRequest, opts ...grpc.CallOption) (*dedicatedv1.CompatProvider, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCompatProvider", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CompatProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCompatProvider indicates an expected call of GetCompatProvider.
func (mr *MockDedicatedGlobalMockRecorder) GetCompatProvider(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompatProvider", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetCompatProvider), varargs...)
}

// GetComponentNodeInfo mocks base method.
func (m *MockDedicatedGlobal) GetComponentNodeInfo(ctx context.Context, in *dedicatedv1.GetComponentNodeInfoRequest, opts ...grpc.CallOption) (*dedicatedv1.GetComponentNodeInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetComponentNodeInfo", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetComponentNodeInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetComponentNodeInfo indicates an expected call of GetComponentNodeInfo.
func (mr *MockDedicatedGlobalMockRecorder) GetComponentNodeInfo(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComponentNodeInfo", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetComponentNodeInfo), varargs...)
}

// GetCustomerManagedEncryptionKey mocks base method.
func (m *MockDedicatedGlobal) GetCustomerManagedEncryptionKey(ctx context.Context, in *dedicatedv1.GetCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*dedicatedv1.CustomerManagedEncryptionKey, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCustomerManagedEncryptionKey", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.CustomerManagedEncryptionKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomerManagedEncryptionKey indicates an expected call of GetCustomerManagedEncryptionKey.
func (mr *MockDedicatedGlobalMockRecorder) GetCustomerManagedEncryptionKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomerManagedEncryptionKey", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetCustomerManagedEncryptionKey), varargs...)
}

// GetDefaultCidr mocks base method.
func (m *MockDedicatedGlobal) GetDefaultCidr(ctx context.Context, in *dedicatedv1.GetDefaultCidrRequest, opts ...grpc.CallOption) (*dedicatedv1.GetDefaultCidrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDefaultCidr", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetDefaultCidrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultCidr indicates an expected call of GetDefaultCidr.
func (mr *MockDedicatedGlobalMockRecorder) GetDefaultCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCidr", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetDefaultCidr), varargs...)
}

// GetDefaultTidbVersion mocks base method.
func (m *MockDedicatedGlobal) GetDefaultTidbVersion(ctx context.Context, in *dedicatedv1.GetDefaultTidbVersionRequest, opts ...grpc.CallOption) (*dedicatedv1.GetDefaultTidbVersionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDefaultTidbVersion", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetDefaultTidbVersionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultTidbVersion indicates an expected call of GetDefaultTidbVersion.
func (mr *MockDedicatedGlobalMockRecorder) GetDefaultTidbVersion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultTidbVersion", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetDefaultTidbVersion), varargs...)
}

// GetGKEHeterogeneousDeploy mocks base method.
func (m *MockDedicatedGlobal) GetGKEHeterogeneousDeploy(ctx context.Context, in *dedicatedv1.GetGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*dedicatedv1.GKEHeterogeneousDeploy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGKEHeterogeneousDeploy", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GKEHeterogeneousDeploy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGKEHeterogeneousDeploy indicates an expected call of GetGKEHeterogeneousDeploy.
func (mr *MockDedicatedGlobalMockRecorder) GetGKEHeterogeneousDeploy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGKEHeterogeneousDeploy", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetGKEHeterogeneousDeploy), varargs...)
}

// GetInstanceMu mocks base method.
func (m *MockDedicatedGlobal) GetInstanceMu(ctx context.Context, in *dedicatedv1.GetInstanceMuRequest, opts ...grpc.CallOption) (*dedicatedv1.InstanceMu, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceMu", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.InstanceMu)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceMu indicates an expected call of GetInstanceMu.
func (mr *MockDedicatedGlobalMockRecorder) GetInstanceMu(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMu", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetInstanceMu), varargs...)
}

// GetLogRedactionPolicy mocks base method.
func (m *MockDedicatedGlobal) GetLogRedactionPolicy(ctx context.Context, in *dedicatedv1.GetLogRedactionPolicyRequest, opts ...grpc.CallOption) (*dedicatedv1.LogRedactionPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLogRedactionPolicy", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.LogRedactionPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogRedactionPolicy indicates an expected call of GetLogRedactionPolicy.
func (mr *MockDedicatedGlobalMockRecorder) GetLogRedactionPolicy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogRedactionPolicy", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetLogRedactionPolicy), varargs...)
}

// GetPrivateLinkIPAddressType mocks base method.
func (m *MockDedicatedGlobal) GetPrivateLinkIPAddressType(ctx context.Context, in *dedicatedv1.GetPrivateLinkIPAddressTypeRequest, opts ...grpc.CallOption) (*dedicatedv1.TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPrivateLinkIPAddressType", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.TidbGroupPrivateLinkIPAddressTypeStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrivateLinkIPAddressType indicates an expected call of GetPrivateLinkIPAddressType.
func (mr *MockDedicatedGlobalMockRecorder) GetPrivateLinkIPAddressType(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateLinkIPAddressType", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetPrivateLinkIPAddressType), varargs...)
}

// GetPrivateLinkService mocks base method.
func (m *MockDedicatedGlobal) GetPrivateLinkService(ctx context.Context, in *dedicatedv1.GetPrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.GetPrivateLinkServiceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPrivateLinkService", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.GetPrivateLinkServiceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrivateLinkService indicates an expected call of GetPrivateLinkService.
func (mr *MockDedicatedGlobalMockRecorder) GetPrivateLinkService(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateLinkService", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetPrivateLinkService), varargs...)
}

// GetPrivateLinkServiceMigration mocks base method.
func (m *MockDedicatedGlobal) GetPrivateLinkServiceMigration(ctx context.Context, in *dedicatedv1.GetPrivateLinkServiceMigrationRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkServiceMigration, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPrivateLinkServiceMigration", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.PrivateLinkServiceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrivateLinkServiceMigration indicates an expected call of GetPrivateLinkServiceMigration.
func (mr *MockDedicatedGlobalMockRecorder) GetPrivateLinkServiceMigration(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateLinkServiceMigration", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetPrivateLinkServiceMigration), varargs...)
}

// GetRegionByLogicalName mocks base method.
func (m *MockDedicatedGlobal) GetRegionByLogicalName(ctx context.Context, in *dedicatedv1.GetRegionByLogicalNameRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRegionByLogicalName", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionByLogicalName indicates an expected call of GetRegionByLogicalName.
func (mr *MockDedicatedGlobalMockRecorder) GetRegionByLogicalName(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionByLogicalName", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetRegionByLogicalName), varargs...)
}

// GetSku mocks base method.
func (m *MockDedicatedGlobal) GetSku(ctx context.Context, in *dedicatedv1.GetSkuRequest, opts ...grpc.CallOption) (*dedicatedv1.Sku, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSku", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Sku)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSku indicates an expected call of GetSku.
func (mr *MockDedicatedGlobalMockRecorder) GetSku(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSku", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetSku), varargs...)
}

// GetSpu mocks base method.
func (m *MockDedicatedGlobal) GetSpu(ctx context.Context, in *dedicatedv1.GetSpuRequest, opts ...grpc.CallOption) (*dedicatedv1.Spu, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSpu", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Spu)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSpu indicates an expected call of GetSpu.
func (mr *MockDedicatedGlobalMockRecorder) GetSpu(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpu", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetSpu), varargs...)
}

// GetStorageMu mocks base method.
func (m *MockDedicatedGlobal) GetStorageMu(ctx context.Context, in *dedicatedv1.GetStorageMuRequest, opts ...grpc.CallOption) (*dedicatedv1.StorageMu, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStorageMu", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.StorageMu)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStorageMu indicates an expected call of GetStorageMu.
func (mr *MockDedicatedGlobalMockRecorder) GetStorageMu(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageMu", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetStorageMu), varargs...)
}

// GetVpcPeering mocks base method.
func (m *MockDedicatedGlobal) GetVpcPeering(ctx context.Context, in *dedicatedv1.GetVpcPeeringRequest, opts ...grpc.CallOption) (*dedicatedv1.VpcPeering, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpcPeering", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.VpcPeering)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVpcPeering indicates an expected call of GetVpcPeering.
func (mr *MockDedicatedGlobalMockRecorder) GetVpcPeering(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpcPeering", reflect.TypeOf((*MockDedicatedGlobal)(nil).GetVpcPeering), varargs...)
}

// ListAuditLogFilterRules mocks base method.
func (m *MockDedicatedGlobal) ListAuditLogFilterRules(ctx context.Context, in *dedicatedv1.ListAuditLogFilterRulesRequest, opts ...grpc.CallOption) (*dedicatedv1.ListAuditLogFilterRulesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAuditLogFilterRules", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListAuditLogFilterRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuditLogFilterRules indicates an expected call of ListAuditLogFilterRules.
func (mr *MockDedicatedGlobalMockRecorder) ListAuditLogFilterRules(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuditLogFilterRules", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListAuditLogFilterRules), varargs...)
}

// ListCloudProviders mocks base method.
func (m *MockDedicatedGlobal) ListCloudProviders(ctx context.Context, in *dedicatedv1.ListCloudProvidersRequest, opts ...grpc.CallOption) (*dedicatedv1.ListCloudProvidersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCloudProviders", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListCloudProvidersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCloudProviders indicates an expected call of ListCloudProviders.
func (mr *MockDedicatedGlobalMockRecorder) ListCloudProviders(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCloudProviders", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListCloudProviders), varargs...)
}

// ListClusterConfigBackup mocks base method.
func (m *MockDedicatedGlobal) ListClusterConfigBackup(ctx context.Context, in *dedicatedv1.ListClusterConfigBackupRequest, opts ...grpc.CallOption) (*dedicatedv1.ListClusterConfigBackupResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterConfigBackup", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListClusterConfigBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterConfigBackup indicates an expected call of ListClusterConfigBackup.
func (mr *MockDedicatedGlobalMockRecorder) ListClusterConfigBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterConfigBackup", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListClusterConfigBackup), varargs...)
}

// ListClusterSnapshots mocks base method.
func (m *MockDedicatedGlobal) ListClusterSnapshots(ctx context.Context, in *dedicatedv1.ListClusterSnapshotsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListClusterSnapshotsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterSnapshots", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListClusterSnapshotsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterSnapshots indicates an expected call of ListClusterSnapshots.
func (mr *MockDedicatedGlobalMockRecorder) ListClusterSnapshots(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterSnapshots", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListClusterSnapshots), varargs...)
}

// ListClusters mocks base method.
func (m *MockDedicatedGlobal) ListClusters(ctx context.Context, in *dedicatedv1.ListClustersRequest, opts ...grpc.CallOption) (*dedicatedv1.ListClustersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusters", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockDedicatedGlobalMockRecorder) ListClusters(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListClusters), varargs...)
}

// ListCustomerManagedEncryptionKeys mocks base method.
func (m *MockDedicatedGlobal) ListCustomerManagedEncryptionKeys(ctx context.Context, in *dedicatedv1.ListCustomerManagedEncryptionKeysRequest, opts ...grpc.CallOption) (*dedicatedv1.ListCustomerManagedEncryptionKeysResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCustomerManagedEncryptionKeys", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListCustomerManagedEncryptionKeysResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCustomerManagedEncryptionKeys indicates an expected call of ListCustomerManagedEncryptionKeys.
func (mr *MockDedicatedGlobalMockRecorder) ListCustomerManagedEncryptionKeys(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomerManagedEncryptionKeys", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListCustomerManagedEncryptionKeys), varargs...)
}

// ListInstanceMus mocks base method.
func (m *MockDedicatedGlobal) ListInstanceMus(ctx context.Context, in *dedicatedv1.ListInstanceMusRequest, opts ...grpc.CallOption) (*dedicatedv1.ListInstanceMusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInstanceMus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListInstanceMusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInstanceMus indicates an expected call of ListInstanceMus.
func (mr *MockDedicatedGlobalMockRecorder) ListInstanceMus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceMus", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListInstanceMus), varargs...)
}

// ListPrivateLinkEndpoints mocks base method.
func (m *MockDedicatedGlobal) ListPrivateLinkEndpoints(ctx context.Context, in *dedicatedv1.ListPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListPrivateLinkEndpointsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPrivateLinkEndpoints", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListPrivateLinkEndpointsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrivateLinkEndpoints indicates an expected call of ListPrivateLinkEndpoints.
func (mr *MockDedicatedGlobalMockRecorder) ListPrivateLinkEndpoints(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrivateLinkEndpoints", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListPrivateLinkEndpoints), varargs...)
}

// ListPrivateLinkServiceMigrations mocks base method.
func (m *MockDedicatedGlobal) ListPrivateLinkServiceMigrations(ctx context.Context, in *dedicatedv1.ListPrivateLinkServiceMigrationsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListPrivateLinkServiceMigrationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPrivateLinkServiceMigrations", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListPrivateLinkServiceMigrationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrivateLinkServiceMigrations indicates an expected call of ListPrivateLinkServiceMigrations.
func (mr *MockDedicatedGlobalMockRecorder) ListPrivateLinkServiceMigrations(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrivateLinkServiceMigrations", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListPrivateLinkServiceMigrations), varargs...)
}

// ListRegions mocks base method.
func (m *MockDedicatedGlobal) ListRegions(ctx context.Context, in *dedicatedv1.ListRegionsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListRegionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRegions", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListRegionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRegions indicates an expected call of ListRegions.
func (mr *MockDedicatedGlobalMockRecorder) ListRegions(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegions", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListRegions), varargs...)
}

// ListSkus mocks base method.
func (m *MockDedicatedGlobal) ListSkus(ctx context.Context, in *dedicatedv1.ListSkusRequest, opts ...grpc.CallOption) (*dedicatedv1.ListSkusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSkus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListSkusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSkus indicates an expected call of ListSkus.
func (mr *MockDedicatedGlobalMockRecorder) ListSkus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSkus", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListSkus), varargs...)
}

// ListSpus mocks base method.
func (m *MockDedicatedGlobal) ListSpus(ctx context.Context, in *dedicatedv1.ListSpusRequest, opts ...grpc.CallOption) (*dedicatedv1.ListSpusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSpus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListSpusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSpus indicates an expected call of ListSpus.
func (mr *MockDedicatedGlobalMockRecorder) ListSpus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpus", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListSpus), varargs...)
}

// ListStorageMus mocks base method.
func (m *MockDedicatedGlobal) ListStorageMus(ctx context.Context, in *dedicatedv1.ListStorageMusRequest, opts ...grpc.CallOption) (*dedicatedv1.ListStorageMusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListStorageMus", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListStorageMusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStorageMus indicates an expected call of ListStorageMus.
func (mr *MockDedicatedGlobalMockRecorder) ListStorageMus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStorageMus", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListStorageMus), varargs...)
}

// ListTenantQuota mocks base method.
func (m *MockDedicatedGlobal) ListTenantQuota(ctx context.Context, in *dedicatedv1.ListTenantQuotaRequest, opts ...grpc.CallOption) (*dedicatedv1.ListTenantQuotaResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTenantQuota", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListTenantQuotaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTenantQuota indicates an expected call of ListTenantQuota.
func (mr *MockDedicatedGlobalMockRecorder) ListTenantQuota(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTenantQuota", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListTenantQuota), varargs...)
}

// ListTidbNodeGroupPrivateLinkEndpoints mocks base method.
func (m *MockDedicatedGlobal) ListTidbNodeGroupPrivateLinkEndpoints(ctx context.Context, in *dedicatedv1.ListTidbNodeGroupPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListTidbNodeGroupPrivateLinkEndpointsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTidbNodeGroupPrivateLinkEndpoints", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListTidbNodeGroupPrivateLinkEndpointsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTidbNodeGroupPrivateLinkEndpoints indicates an expected call of ListTidbNodeGroupPrivateLinkEndpoints.
func (mr *MockDedicatedGlobalMockRecorder) ListTidbNodeGroupPrivateLinkEndpoints(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTidbNodeGroupPrivateLinkEndpoints", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListTidbNodeGroupPrivateLinkEndpoints), varargs...)
}

// ListTidbNodeGroups mocks base method.
func (m *MockDedicatedGlobal) ListTidbNodeGroups(ctx context.Context, in *dedicatedv1.ListTidbNodeGroupsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListTidbNodeGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTidbNodeGroups", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListTidbNodeGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTidbNodeGroups indicates an expected call of ListTidbNodeGroups.
func (mr *MockDedicatedGlobalMockRecorder) ListTidbNodeGroups(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTidbNodeGroups", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListTidbNodeGroups), varargs...)
}

// ListVpcPeerings mocks base method.
func (m *MockDedicatedGlobal) ListVpcPeerings(ctx context.Context, in *dedicatedv1.ListVpcPeeringsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListVpcPeeringsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVpcPeerings", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListVpcPeeringsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVpcPeerings indicates an expected call of ListVpcPeerings.
func (mr *MockDedicatedGlobalMockRecorder) ListVpcPeerings(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVpcPeerings", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListVpcPeerings), varargs...)
}

// ListVpcs mocks base method.
func (m *MockDedicatedGlobal) ListVpcs(ctx context.Context, in *dedicatedv1.ListVpcsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListVpcsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVpcs", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.ListVpcsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVpcs indicates an expected call of ListVpcs.
func (mr *MockDedicatedGlobalMockRecorder) ListVpcs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVpcs", reflect.TypeOf((*MockDedicatedGlobal)(nil).ListVpcs), varargs...)
}

// PauseCluster mocks base method.
func (m *MockDedicatedGlobal) PauseCluster(ctx context.Context, in *dedicatedv1.PauseClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PauseCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PauseCluster indicates an expected call of PauseCluster.
func (mr *MockDedicatedGlobalMockRecorder) PauseCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).PauseCluster), varargs...)
}

// PausePrivateLinkService mocks base method.
func (m *MockDedicatedGlobal) PausePrivateLinkService(ctx context.Context, in *dedicatedv1.PausePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PausePrivateLinkService", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PausePrivateLinkService indicates an expected call of PausePrivateLinkService.
func (mr *MockDedicatedGlobalMockRecorder) PausePrivateLinkService(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PausePrivateLinkService", reflect.TypeOf((*MockDedicatedGlobal)(nil).PausePrivateLinkService), varargs...)
}

// PrecheckAuditLogConfig mocks base method.
func (m *MockDedicatedGlobal) PrecheckAuditLogConfig(ctx context.Context, in *dedicatedv1.PrecheckAuditLogConfigRequest, opts ...grpc.CallOption) (*dedicatedv1.PrecheckAuditLogConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PrecheckAuditLogConfig", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.PrecheckAuditLogConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrecheckAuditLogConfig indicates an expected call of PrecheckAuditLogConfig.
func (mr *MockDedicatedGlobalMockRecorder) PrecheckAuditLogConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrecheckAuditLogConfig", reflect.TypeOf((*MockDedicatedGlobal)(nil).PrecheckAuditLogConfig), varargs...)
}

// PurgePrivateLinkServiceMetadata mocks base method.
func (m *MockDedicatedGlobal) PurgePrivateLinkServiceMetadata(ctx context.Context, in *dedicatedv1.PurgePrivateLinkServiceMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurgePrivateLinkServiceMetadata", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgePrivateLinkServiceMetadata indicates an expected call of PurgePrivateLinkServiceMetadata.
func (mr *MockDedicatedGlobalMockRecorder) PurgePrivateLinkServiceMetadata(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgePrivateLinkServiceMetadata", reflect.TypeOf((*MockDedicatedGlobal)(nil).PurgePrivateLinkServiceMetadata), varargs...)
}

// QueryAuditLogFiles mocks base method.
func (m *MockDedicatedGlobal) QueryAuditLogFiles(ctx context.Context, in *dedicatedv1.QueryAuditLogFilesRequest, opts ...grpc.CallOption) (*dedicatedv1.QueryAuditLogFilesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryAuditLogFiles", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.QueryAuditLogFilesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryAuditLogFiles indicates an expected call of QueryAuditLogFiles.
func (mr *MockDedicatedGlobalMockRecorder) QueryAuditLogFiles(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryAuditLogFiles", reflect.TypeOf((*MockDedicatedGlobal)(nil).QueryAuditLogFiles), varargs...)
}

// QueryCidrs mocks base method.
func (m *MockDedicatedGlobal) QueryCidrs(ctx context.Context, in *dedicatedv1.QueryCidrsRequest, opts ...grpc.CallOption) (*dedicatedv1.QueryCidrsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryCidrs", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.QueryCidrsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryCidrs indicates an expected call of QueryCidrs.
func (mr *MockDedicatedGlobalMockRecorder) QueryCidrs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCidrs", reflect.TypeOf((*MockDedicatedGlobal)(nil).QueryCidrs), varargs...)
}

// RegisterCloudProvider mocks base method.
func (m *MockDedicatedGlobal) RegisterCloudProvider(ctx context.Context, in *dedicatedv1.RegisterCloudProviderRequest, opts ...grpc.CallOption) (*commonv1.CloudProvider, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterCloudProvider", varargs...)
	ret0, _ := ret[0].(*commonv1.CloudProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterCloudProvider indicates an expected call of RegisterCloudProvider.
func (mr *MockDedicatedGlobalMockRecorder) RegisterCloudProvider(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCloudProvider", reflect.TypeOf((*MockDedicatedGlobal)(nil).RegisterCloudProvider), varargs...)
}

// RegisterRegion mocks base method.
func (m *MockDedicatedGlobal) RegisterRegion(ctx context.Context, in *dedicatedv1.RegisterRegionRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterRegion", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterRegion indicates an expected call of RegisterRegion.
func (mr *MockDedicatedGlobalMockRecorder) RegisterRegion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRegion", reflect.TypeOf((*MockDedicatedGlobal)(nil).RegisterRegion), varargs...)
}

// RejectVpcEndpointConnections mocks base method.
func (m *MockDedicatedGlobal) RejectVpcEndpointConnections(ctx context.Context, in *dedicatedv1.RejectVpcEndpointConnectionsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RejectVpcEndpointConnections", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectVpcEndpointConnections indicates an expected call of RejectVpcEndpointConnections.
func (mr *MockDedicatedGlobalMockRecorder) RejectVpcEndpointConnections(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockDedicatedGlobal)(nil).RejectVpcEndpointConnections), varargs...)
}

// ReplaceAuditLogFilterRule mocks base method.
func (m *MockDedicatedGlobal) ReplaceAuditLogFilterRule(ctx context.Context, in *dedicatedv1.ReplaceAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*dedicatedv1.AuditLogFilterRule, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceAuditLogFilterRule", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.AuditLogFilterRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceAuditLogFilterRule indicates an expected call of ReplaceAuditLogFilterRule.
func (mr *MockDedicatedGlobalMockRecorder) ReplaceAuditLogFilterRule(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceAuditLogFilterRule", reflect.TypeOf((*MockDedicatedGlobal)(nil).ReplaceAuditLogFilterRule), varargs...)
}

// ResumeCluster mocks base method.
func (m *MockDedicatedGlobal) ResumeCluster(ctx context.Context, in *dedicatedv1.ResumeClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResumeCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResumeCluster indicates an expected call of ResumeCluster.
func (mr *MockDedicatedGlobalMockRecorder) ResumeCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).ResumeCluster), varargs...)
}

// RunDedicatedToPremiumCompatibilityCheck mocks base method.
func (m *MockDedicatedGlobal) RunDedicatedToPremiumCompatibilityCheck(ctx context.Context, in *dedicatedv1.RunDedicatedToPremiumCompatibilityCheckRequest, opts ...grpc.CallOption) (*dedicatedv1.RunDedicatedToPremiumCompatibilityCheckResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunDedicatedToPremiumCompatibilityCheck", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.RunDedicatedToPremiumCompatibilityCheckResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunDedicatedToPremiumCompatibilityCheck indicates an expected call of RunDedicatedToPremiumCompatibilityCheck.
func (mr *MockDedicatedGlobalMockRecorder) RunDedicatedToPremiumCompatibilityCheck(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunDedicatedToPremiumCompatibilityCheck", reflect.TypeOf((*MockDedicatedGlobal)(nil).RunDedicatedToPremiumCompatibilityCheck), varargs...)
}

// ScaleCluster mocks base method.
func (m *MockDedicatedGlobal) ScaleCluster(ctx context.Context, in *dedicatedv1.ScaleClusterRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScaleCluster", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScaleCluster indicates an expected call of ScaleCluster.
func (mr *MockDedicatedGlobalMockRecorder) ScaleCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).ScaleCluster), varargs...)
}

// ScaleClusterWithMultiComponent mocks base method.
func (m *MockDedicatedGlobal) ScaleClusterWithMultiComponent(ctx context.Context, in *dedicatedv1.ScaleClusterWithMultiComponentRequest, opts ...grpc.CallOption) (*dedicatedv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScaleClusterWithMultiComponent", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScaleClusterWithMultiComponent indicates an expected call of ScaleClusterWithMultiComponent.
func (mr *MockDedicatedGlobalMockRecorder) ScaleClusterWithMultiComponent(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleClusterWithMultiComponent", reflect.TypeOf((*MockDedicatedGlobal)(nil).ScaleClusterWithMultiComponent), varargs...)
}

// SelectRegionByOrgId mocks base method.
func (m *MockDedicatedGlobal) SelectRegionByOrgId(ctx context.Context, in *dedicatedv1.SelectRegionByOrgIdRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SelectRegionByOrgId", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectRegionByOrgId indicates an expected call of SelectRegionByOrgId.
func (mr *MockDedicatedGlobalMockRecorder) SelectRegionByOrgId(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectRegionByOrgId", reflect.TypeOf((*MockDedicatedGlobal)(nil).SelectRegionByOrgId), varargs...)
}

// SetClientCaCertificate mocks base method.
func (m *MockDedicatedGlobal) SetClientCaCertificate(ctx context.Context, in *dedicatedv1.SetClientCaCertificateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetClientCaCertificate", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetClientCaCertificate indicates an expected call of SetClientCaCertificate.
func (mr *MockDedicatedGlobalMockRecorder) SetClientCaCertificate(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetClientCaCertificate", reflect.TypeOf((*MockDedicatedGlobal)(nil).SetClientCaCertificate), varargs...)
}

// SetPrivateLinkIPAddressType mocks base method.
func (m *MockDedicatedGlobal) SetPrivateLinkIPAddressType(ctx context.Context, in *dedicatedv1.SetPrivateLinkIPAddressTypeRequest, opts ...grpc.CallOption) (*dedicatedv1.TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetPrivateLinkIPAddressType", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.TidbGroupPrivateLinkIPAddressTypeStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetPrivateLinkIPAddressType indicates an expected call of SetPrivateLinkIPAddressType.
func (mr *MockDedicatedGlobalMockRecorder) SetPrivateLinkIPAddressType(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrivateLinkIPAddressType", reflect.TypeOf((*MockDedicatedGlobal)(nil).SetPrivateLinkIPAddressType), varargs...)
}

// ShutdownUpgradeCluster mocks base method.
func (m *MockDedicatedGlobal) ShutdownUpgradeCluster(ctx context.Context, in *dedicatedv1.ShutdownUpgradeClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShutdownUpgradeCluster", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShutdownUpgradeCluster indicates an expected call of ShutdownUpgradeCluster.
func (mr *MockDedicatedGlobalMockRecorder) ShutdownUpgradeCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownUpgradeCluster", reflect.TypeOf((*MockDedicatedGlobal)(nil).ShutdownUpgradeCluster), varargs...)
}

// SyncPdOnlineConfig mocks base method.
func (m *MockDedicatedGlobal) SyncPdOnlineConfig(ctx context.Context, in *dedicatedv1.SyncPdOnlineConfigRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncPdOnlineConfig", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncPdOnlineConfig indicates an expected call of SyncPdOnlineConfig.
func (mr *MockDedicatedGlobalMockRecorder) SyncPdOnlineConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPdOnlineConfig", reflect.TypeOf((*MockDedicatedGlobal)(nil).SyncPdOnlineConfig), varargs...)
}

// SyncSystemVariables mocks base method.
func (m *MockDedicatedGlobal) SyncSystemVariables(ctx context.Context, in *dedicatedv1.SyncSystemVariablesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncSystemVariables", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncSystemVariables indicates an expected call of SyncSystemVariables.
func (mr *MockDedicatedGlobalMockRecorder) SyncSystemVariables(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncSystemVariables", reflect.TypeOf((*MockDedicatedGlobal)(nil).SyncSystemVariables), varargs...)
}

// UpdateAuditLogConfig mocks base method.
func (m *MockDedicatedGlobal) UpdateAuditLogConfig(ctx context.Context, in *dedicatedv1.UpdateAuditLogConfigRequest, opts ...grpc.CallOption) (*dedicatedv1.AuditLogConfig, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAuditLogConfig", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.AuditLogConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAuditLogConfig indicates an expected call of UpdateAuditLogConfig.
func (mr *MockDedicatedGlobalMockRecorder) UpdateAuditLogConfig(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuditLogConfig", reflect.TypeOf((*MockDedicatedGlobal)(nil).UpdateAuditLogConfig), varargs...)
}

// UpdateCidr mocks base method.
func (m *MockDedicatedGlobal) UpdateCidr(ctx context.Context, in *dedicatedv1.UpdateCidrRequest, opts ...grpc.CallOption) (*dedicatedv1.UpdateCidrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCidr", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.UpdateCidrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCidr indicates an expected call of UpdateCidr.
func (mr *MockDedicatedGlobalMockRecorder) UpdateCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCidr", reflect.TypeOf((*MockDedicatedGlobal)(nil).UpdateCidr), varargs...)
}

// UpdateLogRedactionPolicy mocks base method.
func (m *MockDedicatedGlobal) UpdateLogRedactionPolicy(ctx context.Context, in *dedicatedv1.UpdateLogRedactionPolicyRequest, opts ...grpc.CallOption) (*dedicatedv1.LogRedactionPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateLogRedactionPolicy", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.LogRedactionPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLogRedactionPolicy indicates an expected call of UpdateLogRedactionPolicy.
func (mr *MockDedicatedGlobalMockRecorder) UpdateLogRedactionPolicy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogRedactionPolicy", reflect.TypeOf((*MockDedicatedGlobal)(nil).UpdateLogRedactionPolicy), varargs...)
}

// UpdateRegion mocks base method.
func (m *MockDedicatedGlobal) UpdateRegion(ctx context.Context, in *dedicatedv1.UpdateRegionRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRegion", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRegion indicates an expected call of UpdateRegion.
func (mr *MockDedicatedGlobalMockRecorder) UpdateRegion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRegion", reflect.TypeOf((*MockDedicatedGlobal)(nil).UpdateRegion), varargs...)
}

// UpdateTenantQuota mocks base method.
func (m *MockDedicatedGlobal) UpdateTenantQuota(ctx context.Context, in *dedicatedv1.UpdateTenantQuotaRequest, opts ...grpc.CallOption) (*dedicatedv1.UpdateTenantQuotaResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTenantQuota", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.UpdateTenantQuotaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTenantQuota indicates an expected call of UpdateTenantQuota.
func (mr *MockDedicatedGlobalMockRecorder) UpdateTenantQuota(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTenantQuota", reflect.TypeOf((*MockDedicatedGlobal)(nil).UpdateTenantQuota), varargs...)
}

// UpdateTidbNodeGroup mocks base method.
func (m *MockDedicatedGlobal) UpdateTidbNodeGroup(ctx context.Context, in *dedicatedv1.UpdateTidbNodeGroupRequest, opts ...grpc.CallOption) (*dedicatedv1.TidbNodeGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTidbNodeGroup", varargs...)
	ret0, _ := ret[0].(*dedicatedv1.TidbNodeGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTidbNodeGroup indicates an expected call of UpdateTidbNodeGroup.
func (mr *MockDedicatedGlobalMockRecorder) UpdateTidbNodeGroup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTidbNodeGroup", reflect.TypeOf((*MockDedicatedGlobal)(nil).UpdateTidbNodeGroup), varargs...)
}