package globaldedicatedcli

import (
	"context"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"

	globalcommonv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	globaldedicatedv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/dedicated/v1"
	"github.com/tidbcloud/tidb-management-service/utilities/bizerr"
)

type clientImpl struct {
	clusterCli                     globaldedicatedv1.ClusterServiceClient
	vpcCli                         globaldedicatedv1.VpcServiceClient
	spuCli                         globaldedicatedv1.SpuServiceClient
	cmekCli                        globaldedicatedv1.CustomerManagedEncryptionServiceClient
	regionCli                      globaldedicatedv1.RegionServiceClient
	auditLogCli                    globaldedicatedv1.DatabaseAuditLogServiceClient
	privateLinkCli                 globaldedicatedv1.PrivateLinkConnectionServiceClient
	tidbGroupCli                   globaldedicatedv1.TidbNodeGroupServiceClient
	compatCli                      globaldedicatedv1.DataPlatformCompatServiceClient
	meteringCli                    globaldedicatedv1.MeteringServiceClient
	privateLinkServiceMigrationCli globaldedicatedv1.PrivateLinkServiceMigrationServiceClient
	migrationPrecheckCli           globaldedicatedv1.MigrationPrecheckServiceClient
}

func (c *clientImpl) RunDedicatedToPremiumCompatibilityCheck(
	ctx context.Context,
	in *globaldedicatedv1.RunDedicatedToPremiumCompatibilityCheckRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.RunDedicatedToPremiumCompatibilityCheckResponse, error) {
	resp, err := c.migrationPrecheckCli.RunDedicatedToPremiumCompatibilityCheck(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RunDedicatedToPremiumCompatibilityCheck")
	}
	return resp, nil
}

func (c *clientImpl) CreateCluster(
	ctx context.Context,
	in *globaldedicatedv1.CreateClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.CreateCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateCluster")
	}
	return resp, nil
}

func (c *clientImpl) ListClusters(
	ctx context.Context,
	in *globaldedicatedv1.ListClustersRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListClustersResponse, error) {
	resp, err := c.clusterCli.ListClusters(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListClusters")
	}
	return resp, nil
}

func (c *clientImpl) GetCluster(
	ctx context.Context,
	in *globaldedicatedv1.GetClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.GetCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCluster")
	}
	return resp, nil
}

// DeleteCluster deletes the cluster but keeps the backup records. The cluster can be restored from the backup.
func (c *clientImpl) DeleteCluster(
	ctx context.Context,
	in *globaldedicatedv1.DeleteClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	cluster, err := c.clusterCli.DeleteCluster(ctx, in, opts...)
	// If the cluster is not found, return nil, nil
	// meaning the cluster is not found and already deleted
	if err != nil {
		if s, ok := status.FromError(err); ok {
			if s.Code() == codes.Code(bizerr.ErrCodeRecordNotFound) {
				return &globaldedicatedv1.Cluster{}, nil
			}
		}
		return nil, bizerr.WrapGrpcError(err, "DeleteCluster")
	}
	return cluster, nil
}

func (c *clientImpl) ScaleCluster(
	ctx context.Context,
	in *globaldedicatedv1.ScaleClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.ScaleCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ScaleCluster")
	}
	return resp, nil
}

func (c *clientImpl) ScaleClusterWithMultiComponent(
	ctx context.Context,
	in *globaldedicatedv1.ScaleClusterWithMultiComponentRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.ScaleClusterWithMultiComponent(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ScaleClusterWithMultiComponent")
	}
	return resp, nil
}

func (c *clientImpl) PauseCluster(
	ctx context.Context,
	in *globaldedicatedv1.PauseClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.PauseCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "PauseCluster")
	}
	return resp, nil
}

func (c *clientImpl) ResumeCluster(
	ctx context.Context,
	in *globaldedicatedv1.ResumeClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.ResumeCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ResumeCluster")
	}
	return resp, nil
}

func (c *clientImpl) GetComponentNodeInfo(
	ctx context.Context,
	in *globaldedicatedv1.GetComponentNodeInfoRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetComponentNodeInfoResponse, error) {
	resp, err := c.clusterCli.GetComponentNodeInfo(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetComponentNodeInfo")
	}
	return resp, nil
}

func (c *clientImpl) ApplyCluster(
	ctx context.Context,
	in *globaldedicatedv1.ApplyClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Cluster, error) {
	resp, err := c.clusterCli.ApplyCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ApplyCluster")
	}
	return resp, nil
}

func (c *clientImpl) ApplyGKEHeterogeneousDeploy(
	ctx context.Context,
	in *globaldedicatedv1.ApplyGKEHeterogeneousDeployRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GKEHeterogeneousDeploy, error) {
	resp, err := c.clusterCli.ApplyGKEHeterogeneousDeploy(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ApplyGKEHeterogeneousDeploy")
	}
	return resp, nil
}

func (c *clientImpl) GetGKEHeterogeneousDeploy(
	ctx context.Context,
	in *globaldedicatedv1.GetGKEHeterogeneousDeployRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GKEHeterogeneousDeploy, error) {
	resp, err := c.clusterCli.GetGKEHeterogeneousDeploy(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetGKEHeterogeneousDeploy")
	}
	return resp, nil
}

func (c *clientImpl) DeleteGKEHeterogeneousDeploy(
	ctx context.Context,
	in *globaldedicatedv1.DeleteGKEHeterogeneousDeployRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.DeleteGKEHeterogeneousDeploy(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteGKEHeterogeneousDeploy")
	}
	return resp, nil
}

func (c *clientImpl) GetClusterConfidentialInfo(
	ctx context.Context,
	in *globaldedicatedv1.GetClusterConfidentialInfoRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetClusterConfidentialInfoResponse, error) {
	resp, err := c.clusterCli.GetClusterConfidentialInfo(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetClusterConfidentialInfo")
	}
	return resp, nil
}

func (c *clientImpl) GetDefaultTidbVersion(
	ctx context.Context,
	in *globaldedicatedv1.GetDefaultTidbVersionRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetDefaultTidbVersionResponse, error) {
	resp, err := c.clusterCli.GetDefaultTidbVersion(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetDefaultTidbVersion")
	}
	return resp, nil
}

// Vpc service
func (c *clientImpl) ListVpcs(
	ctx context.Context,
	in *globaldedicatedv1.ListVpcsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListVpcsResponse, error) {
	resp, err := c.vpcCli.ListVpcs(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListVpcs")
	}
	return resp, nil
}

func (c *clientImpl) DeleteVpc(
	ctx context.Context,
	in *globaldedicatedv1.DeleteVpcRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.vpcCli.DeleteVpc(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteVpc")
	}
	return resp, nil
}

func (c *clientImpl) DeleteVpcPeering(
	ctx context.Context,
	in *globaldedicatedv1.DeleteVpcPeeringRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.vpcCli.DeleteVpcPeering(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteVpcPeering")
	}
	return resp, nil
}

func (c *clientImpl) ListVpcPeerings(
	ctx context.Context,
	in *globaldedicatedv1.ListVpcPeeringsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListVpcPeeringsResponse, error) {
	resp, err := c.vpcCli.ListVpcPeerings(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListVpcPeerings")
	}
	return resp, nil
}

func (c *clientImpl) GetCmekAccessIamPrincipal(
	ctx context.Context,
	in *globaldedicatedv1.GetCmekAccessIamPrincipalRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetCmekAccessIamPrincipalResponse, error) {
	resp, err := c.cmekCli.GetCmekAccessIamPrincipal(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCmekAccessIamPrincipal")
	}
	return resp, nil
}

// Region Service

func (c *clientImpl) RegisterCloudProvider(
	ctx context.Context,
	in *globaldedicatedv1.RegisterCloudProviderRequest,
	opts ...grpc.CallOption,
) (*globalcommonv1.CloudProvider, error) {
	resp, err := c.regionCli.RegisterCloudProvider(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RegisterCloudProvider")
	}
	return resp, nil
}

func (c *clientImpl) ListCloudProviders(
	ctx context.Context,
	req *globaldedicatedv1.ListCloudProvidersRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListCloudProvidersResponse, error) {
	resp, err := c.regionCli.ListCloudProviders(ctx, req, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListCloudProviders")
	}
	return resp, nil
}

func (c *clientImpl) RegisterRegion(
	ctx context.Context,
	in *globaldedicatedv1.RegisterRegionRequest,
	opts ...grpc.CallOption,
) (*globalcommonv1.Region, error) {
	resp, err := c.regionCli.RegisterRegion(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RegisterRegion")
	}
	return resp, nil
}

func (c *clientImpl) UpdateRegion(
	ctx context.Context,
	in *globaldedicatedv1.UpdateRegionRequest,
	opts ...grpc.CallOption,
) (*globalcommonv1.Region, error) {
	resp, err := c.regionCli.UpdateRegion(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateRegion")
	}
	return resp, nil
}

func (c *clientImpl) SelectRegionByOrgId(
	ctx context.Context,
	in *globaldedicatedv1.SelectRegionByOrgIdRequest,
	opts ...grpc.CallOption,
) (*globalcommonv1.Region, error) {
	resp, err := c.regionCli.SelectRegionByOrgId(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "SelectRegionByOrgId")
	}
	return resp, nil
}

func (c *clientImpl) GetRegionByLogicalName(
	ctx context.Context,
	in *globaldedicatedv1.GetRegionByLogicalNameRequest,
	opts ...grpc.CallOption,
) (*globalcommonv1.Region, error) {
	resp, err := c.regionCli.GetRegionByLogicalName(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetRegionByLogicalName")
	}
	return resp, nil
}

func (c *clientImpl) ListRegions(
	ctx context.Context,
	in *globaldedicatedv1.ListRegionsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListRegionsResponse, error) {
	resp, err := c.regionCli.ListRegions(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListRegions")
	}
	return resp, nil
}

func (c *clientImpl) CheckRegionStatus(
	ctx context.Context,
	in *globaldedicatedv1.CheckRegionStatusRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.regionCli.CheckRegionStatus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CheckRegionStatus")
	}
	return resp, nil
}

func (c *clientImpl) DeleteRegion(
	ctx context.Context,
	in *globaldedicatedv1.DeleteRegionRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.regionCli.DeleteRegion(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteRegion")
	}
	return resp, nil
}

// Certificate service

func (c *clientImpl) SetClientCaCertificate(
	ctx context.Context,
	in *globaldedicatedv1.SetClientCaCertificateRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.SetClientCaCertificate(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "SetClientCaCertificate")
	}
	return resp, nil
}

func (c *clientImpl) GetClientCaCertificate(
	ctx context.Context,
	in *globaldedicatedv1.GetClientCaCertificateRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetClientCaCertificateResponse, error) {
	resp, err := c.clusterCli.GetClientCaCertificate(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetClientCaCertificate")
	}
	return resp, nil
}

func (c *clientImpl) GetBillableClustersCount(
	ctx context.Context,
	in *globaldedicatedv1.GetBillableClustersCountRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetBillableClustersCountResponse, error) {
	resp, err := c.clusterCli.GetBillableClustersCount(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetBillableClustersCount")
	}
	return resp, nil
}

func (c *clientImpl) CreateCustomerManagedEncryptionKey(
	ctx context.Context,
	in *globaldedicatedv1.CreateCustomerManagedEncryptionKeyRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CustomerManagedEncryptionKey, error) {
	resp, err := c.cmekCli.CreateCustomerManagedEncryptionKey(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateCustomerManagedEncryptionKey")
	}
	return resp, nil
}

func (c *clientImpl) GetCustomerManagedEncryptionKey(
	ctx context.Context,
	in *globaldedicatedv1.GetCustomerManagedEncryptionKeyRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CustomerManagedEncryptionKey, error) {
	resp, err := c.cmekCli.GetCustomerManagedEncryptionKey(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCustomerManagedEncryptionKey")
	}
	return resp, nil
}

func (c *clientImpl) ListCustomerManagedEncryptionKeys(
	ctx context.Context,
	in *globaldedicatedv1.ListCustomerManagedEncryptionKeysRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListCustomerManagedEncryptionKeysResponse, error) {
	resp, err := c.cmekCli.ListCustomerManagedEncryptionKeys(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListCustomerManagedEncryptionKeys")
	}
	return resp, nil
}

func (c *clientImpl) DeleteCustomerManagedEncryptionKey(
	ctx context.Context,
	in *globaldedicatedv1.DeleteCustomerManagedEncryptionKeyRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.cmekCli.DeleteCustomerManagedEncryptionKey(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteCustomerManagedEncryptionKey")
	}
	return resp, nil
}

func (c *clientImpl) CreateClusterSnapshot(
	ctx context.Context,
	in *globaldedicatedv1.CreateClusterSnapshotRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CreateClusterSnapshotResponse, error) {
	resp, err := c.clusterCli.CreateClusterSnapshot(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateClusterSnapshot")
	}
	return resp, nil
}

func (c *clientImpl) ListClusterSnapshots(
	ctx context.Context,
	in *globaldedicatedv1.ListClusterSnapshotsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListClusterSnapshotsResponse, error) {
	resp, err := c.clusterCli.ListClusterSnapshots(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListClusterSnapshots")
	}
	return resp, nil
}

func (c *clientImpl) ListTenantQuota(
	ctx context.Context,
	in *globaldedicatedv1.ListTenantQuotaRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListTenantQuotaResponse, error) {
	resp, err := c.clusterCli.ListTenantQuota(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListTenantQuota")
	}
	return resp, nil
}

func (c *clientImpl) UpdateTenantQuota(
	ctx context.Context,
	in *globaldedicatedv1.UpdateTenantQuotaRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.UpdateTenantQuotaResponse, error) {
	resp, err := c.clusterCli.UpdateTenantQuota(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateTenantQuota")
	}
	return resp, nil
}

func (c *clientImpl) ChangeClusterPasswd(
	ctx context.Context,
	in *globaldedicatedv1.ChangeClusterPasswdRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ChangeClusterPasswdResponse, error) {
	resp, err := c.clusterCli.ChangeClusterPasswd(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ChangeClusterPasswd")
	}
	return resp, nil
}

func (c *clientImpl) CreateCidr(
	ctx context.Context,
	in *globaldedicatedv1.CreateCidrRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CreateCidrResponse, error) {
	resp, err := c.vpcCli.CreateCidr(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateCidr")
	}
	return resp, nil
}

func (c *clientImpl) QueryCidrs(
	ctx context.Context,
	in *globaldedicatedv1.QueryCidrsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.QueryCidrsResponse, error) {
	resp, err := c.vpcCli.QueryCidrs(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "QueryCidrs")
	}
	return resp, nil
}

func (c *clientImpl) UpdateCidr(
	ctx context.Context,
	in *globaldedicatedv1.UpdateCidrRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.UpdateCidrResponse, error) {
	resp, err := c.vpcCli.UpdateCidr(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateCidr")
	}
	return resp, nil
}

func (c *clientImpl) DeleteCidr(
	ctx context.Context,
	in *globaldedicatedv1.DeleteCidrRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.vpcCli.DeleteCidr(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteCidr")
	}
	return resp, nil
}

func (c *clientImpl) GetDefaultCidr(
	ctx context.Context,
	in *globaldedicatedv1.GetDefaultCidrRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetDefaultCidrResponse, error) {
	resp, err := c.vpcCli.GetDefaultCidr(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetDefaultCidr")
	}
	return resp, nil
}

func (c *clientImpl) GetAuditLogConfig(
	ctx context.Context,
	in *globaldedicatedv1.GetAuditLogConfigRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.AuditLogConfig, error) {
	resp, err := c.auditLogCli.GetAuditLogConfig(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetAuditLogConfig")
	}
	return resp, nil
}

func (c *clientImpl) UpdateAuditLogConfig(
	ctx context.Context,
	in *globaldedicatedv1.UpdateAuditLogConfigRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.AuditLogConfig, error) {
	resp, err := c.auditLogCli.UpdateAuditLogConfig(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateAuditLogConfig")
	}
	return resp, nil
}

func (c *clientImpl) PrecheckAuditLogConfig(
	ctx context.Context,
	in *globaldedicatedv1.PrecheckAuditLogConfigRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.PrecheckAuditLogConfigResponse, error) {
	resp, err := c.auditLogCli.PrecheckAuditLogConfig(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "PrecheckAuditLogConfig")
	}
	return resp, nil
}

func (c *clientImpl) ListAuditLogFilterRules(
	ctx context.Context,
	in *globaldedicatedv1.ListAuditLogFilterRulesRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListAuditLogFilterRulesResponse, error) {
	resp, err := c.auditLogCli.ListAuditLogFilterRules(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListAuditLogFilterRules")
	}
	return resp, nil
}

func (c *clientImpl) CreateAuditLogFilterRule(
	ctx context.Context,
	in *globaldedicatedv1.CreateAuditLogFilterRuleRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.AuditLogFilterRule, error) {
	resp, err := c.auditLogCli.CreateAuditLogFilterRule(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateAuditLogFilterRule")
	}
	return resp, nil
}

func (c *clientImpl) DeleteAuditLogFilterRule(
	ctx context.Context,
	in *globaldedicatedv1.DeleteAuditLogFilterRuleRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.auditLogCli.DeleteAuditLogFilterRule(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteAuditLogFilterRule")
	}
	return resp, nil
}

func (c *clientImpl) ReplaceAuditLogFilterRule(
	ctx context.Context,
	in *globaldedicatedv1.ReplaceAuditLogFilterRuleRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.AuditLogFilterRule, error) {
	resp, err := c.auditLogCli.ReplaceAuditLogFilterRule(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ReplaceAuditLogFilterRule")
	}
	return resp, nil
}

func (c *clientImpl) QueryAuditLogFiles(
	ctx context.Context,
	in *globaldedicatedv1.QueryAuditLogFilesRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.QueryAuditLogFilesResponse, error) {
	resp, err := c.auditLogCli.QueryAuditLogFiles(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "QueryAuditLogFiles")
	}
	return resp, nil
}

func (c *clientImpl) GenerateAuditLogFileDownloadAddress(
	ctx context.Context,
	in *globaldedicatedv1.GenerateAuditLogFileDownloadAddressRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GenerateAuditLogFileDownloadAddressResponse, error) {
	resp, err := c.auditLogCli.GenerateAuditLogFileDownloadAddress(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GenerateAuditLogFileDownloadAddress")
	}
	return resp, nil
}

func (c *clientImpl) CreatePrivateLinkService(
	ctx context.Context,
	in *globaldedicatedv1.CreatePrivateLinkServiceRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CreatePrivateLinkServiceResponse, error) {
	resp, err := c.privateLinkCli.CreatePrivateLinkService(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreatePrivateLinkService")
	}
	return resp, nil
}

func (c *clientImpl) DeletePrivateLinkService(
	ctx context.Context,
	in *globaldedicatedv1.DeletePrivateLinkServiceRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.privateLinkCli.DeletePrivateLinkService(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeletePrivateLinkService")
	}
	return resp, nil
}

func (c *clientImpl) GetPrivateLinkService(
	ctx context.Context,
	in *globaldedicatedv1.GetPrivateLinkServiceRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetPrivateLinkServiceResponse, error) {
	resp, err := c.privateLinkCli.GetPrivateLinkService(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetPrivateLinkService")
	}
	return resp, nil
}

func (c *clientImpl) CreatePrivateLinkEndpoint(
	ctx context.Context,
	in *globaldedicatedv1.CreatePrivateLinkEndpointRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CreatePrivateLinkEndpointResponse, error) {
	resp, err := c.privateLinkCli.CreatePrivateLinkEndpoint(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreatePrivateLinkEndpoint")
	}
	return resp, nil
}

func (c *clientImpl) DeletePrivateLinkEndpoint(
	ctx context.Context,
	in *globaldedicatedv1.DeletePrivateLinkEndpointRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.privateLinkCli.DeletePrivateLinkEndpoint(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeletePrivateLinkEndpoint")
	}
	return resp, nil
}

func (c *clientImpl) ListPrivateLinkEndpoints(
	ctx context.Context,
	in *globaldedicatedv1.ListPrivateLinkEndpointsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListPrivateLinkEndpointsResponse, error) {
	resp, err := c.privateLinkCli.ListPrivateLinkEndpoints(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListPrivateLinkEndpoints")
	}
	return resp, nil
}

func (c *clientImpl) ListTidbNodeGroupPrivateLinkEndpoints(
	ctx context.Context,
	in *globaldedicatedv1.ListTidbNodeGroupPrivateLinkEndpointsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListTidbNodeGroupPrivateLinkEndpointsResponse, error) {
	resp, err := c.privateLinkCli.ListTidbNodeGroupPrivateLinkEndpoints(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListTidbNodeGroupPrivateLinkEndpoints")
	}
	return resp, nil
}

func (c *clientImpl) RejectVpcEndpointConnections(
	ctx context.Context,
	in *globaldedicatedv1.RejectVpcEndpointConnectionsRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.privateLinkCli.RejectVpcEndpointConnections(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RejectVpcEndpointConnections")
	}
	return resp, nil
}

func (c *clientImpl) PausePrivateLinkService(
	ctx context.Context,
	in *globaldedicatedv1.PausePrivateLinkServiceRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.privateLinkCli.PausePrivateLinkService(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "PausePrivateLinkService")
	}
	return resp, nil
}

func (c *clientImpl) PurgePrivateLinkServiceMetadata(
	ctx context.Context,
	in *globaldedicatedv1.PurgePrivateLinkServiceMetadataRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.privateLinkCli.PurgePrivateLinkServiceMetadata(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "PurgePrivateLinkServiceMetadata")
	}
	return resp, nil
}

func (c *clientImpl) CreateTidbNodeGroup(
	ctx context.Context,
	in *globaldedicatedv1.CreateTidbNodeGroupRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.TidbNodeGroup, error) {
	resp, err := c.tidbGroupCli.CreateTidbNodeGroup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateTidbNodeGroup")
	}
	return resp, nil
}

func (c *clientImpl) UpdateTidbNodeGroup(
	ctx context.Context,
	in *globaldedicatedv1.UpdateTidbNodeGroupRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.TidbNodeGroup, error) {
	resp, err := c.tidbGroupCli.UpdateTidbNodeGroup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateTidbNodeGroup")
	}
	return resp, nil
}

func (c *clientImpl) DeleteTidbNodeGroup(
	ctx context.Context,
	in *globaldedicatedv1.DeleteTidbNodeGroupRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.tidbGroupCli.DeleteTidbNodeGroup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteTidbNodeGroup")
	}
	return resp, nil
}

func (c *clientImpl) ListTidbNodeGroups(
	ctx context.Context,
	in *globaldedicatedv1.ListTidbNodeGroupsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListTidbNodeGroupsResponse, error) {
	resp, err := c.tidbGroupCli.ListTidbNodeGroups(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListTidbNodeGroups")
	}
	return resp, nil
}

func (c *clientImpl) GetVpcPeering(
	ctx context.Context,
	in *globaldedicatedv1.GetVpcPeeringRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.VpcPeering, error) {
	resp, err := c.vpcCli.GetVpcPeering(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetVpcPeering")
	}
	return resp, nil
}

func (c *clientImpl) CreateVpcPeering(
	ctx context.Context,
	in *globaldedicatedv1.CreateVpcPeeringRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CreateVpcPeeringResponse, error) {
	resp, err := c.vpcCli.CreateVpcPeering(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateVpcPeering")
	}
	return resp, nil
}

func (c *clientImpl) GetAccount(
	ctx context.Context,
	in *globaldedicatedv1.GetAccountRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetAccountResponse, error) {
	resp, err := c.auditLogCli.GetAccount(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetAccount")
	}
	return resp, nil
}

func (c *clientImpl) GetCompatCluster(
	ctx context.Context,
	in *globaldedicatedv1.GetCompatClusterRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CompatCluster, error) {
	resp, err := c.compatCli.GetCompatCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCompatCluster")
	}
	return resp, nil
}

func (c *clientImpl) GetCompatNetwork(
	ctx context.Context,
	in *globaldedicatedv1.GetCompatNetworkRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CompatNetwork, error) {
	resp, err := c.compatCli.GetCompatNetwork(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCompatNetwork")
	}
	return resp, nil
}

func (c *clientImpl) GetCompatProvider(
	ctx context.Context,
	in *globaldedicatedv1.GetCompatProviderRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CompatProvider, error) {
	resp, err := c.compatCli.GetCompatProvider(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCompatProvider")
	}
	return resp, nil
}

func (c *clientImpl) CalcClusterFee(
	ctx context.Context,
	in *globaldedicatedv1.CalcClusterFeeRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.CalcClusterFeeResponse, error) {
	resp, err := c.meteringCli.CalcClusterFee(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CalcClusterFee")
	}
	return resp, nil
}

func (c *clientImpl) ListSpus(
	ctx context.Context,
	in *globaldedicatedv1.ListSpusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListSpusResponse, error) {
	resp, err := c.spuCli.ListSpus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListSpus")
	}
	return resp, nil
}

func (c *clientImpl) GetSpu(
	ctx context.Context,
	in *globaldedicatedv1.GetSpuRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Spu, error) {
	resp, err := c.spuCli.GetSpu(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetSpu")
	}
	return resp, nil
}

func (c *clientImpl) BatchUpsertSpus(
	ctx context.Context,
	in *globaldedicatedv1.BatchUpsertSpusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.BatchUpsertSpusResponse, error) {
	resp, err := c.spuCli.BatchUpsertSpus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BatchUpsertSpus")
	}
	return resp, nil
}

func (c *clientImpl) GetInstanceMu(
	ctx context.Context,
	in *globaldedicatedv1.GetInstanceMuRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.InstanceMu, error) {
	resp, err := c.spuCli.GetInstanceMu(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetInstanceMu")
	}
	return resp, nil
}

func (c *clientImpl) GetStorageMu(
	ctx context.Context,
	in *globaldedicatedv1.GetStorageMuRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.StorageMu, error) {
	resp, err := c.spuCli.GetStorageMu(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetStorageMu")
	}
	return resp, nil
}

func (c *clientImpl) ListInstanceMus(
	ctx context.Context,
	in *globaldedicatedv1.ListInstanceMusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListInstanceMusResponse, error) {
	resp, err := c.spuCli.ListInstanceMus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListInstanceMus")
	}
	return resp, nil
}

func (c *clientImpl) ListStorageMus(
	ctx context.Context,
	in *globaldedicatedv1.ListStorageMusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListStorageMusResponse, error) {
	resp, err := c.spuCli.ListStorageMus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListStorageMus")
	}
	return resp, nil
}

func (c *clientImpl) BatchUpsertInstanceMus(
	ctx context.Context,
	in *globaldedicatedv1.BatchUpsertInstanceMusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.BatchUpsertInstanceMusResponse, error) {
	resp, err := c.spuCli.BatchUpsertInstanceMus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BatchUpsertInstanceMus")
	}
	return resp, nil
}

func (c *clientImpl) BatchUpsertStorageMus(
	ctx context.Context,
	in *globaldedicatedv1.BatchUpsertStorageMusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.BatchUpsertStorageMusResponse, error) {
	resp, err := c.spuCli.BatchUpsertStorageMus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BatchUpsertStorageMus")
	}
	return resp, nil
}

func (c *clientImpl) GetSku(
	ctx context.Context,
	in *globaldedicatedv1.GetSkuRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Sku, error) {
	resp, err := c.spuCli.GetSku(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetSku")
	}
	return resp, nil
}

func (c *clientImpl) ListSkus(
	ctx context.Context,
	in *globaldedicatedv1.ListSkusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListSkusResponse, error) {
	resp, err := c.spuCli.ListSkus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListSkus")
	}
	return resp, nil
}

func (c *clientImpl) BatchUpsertSkus(
	ctx context.Context,
	in *globaldedicatedv1.BatchUpsertSkusRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.BatchUpsertSkusResponse, error) {
	resp, err := c.spuCli.BatchUpsertSkus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BatchUpsertSkus")
	}
	return resp, nil
}

func (c *clientImpl) GetLogRedactionPolicy(
	ctx context.Context,
	in *globaldedicatedv1.GetLogRedactionPolicyRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.LogRedactionPolicy, error) {
	resp, err := c.clusterCli.GetLogRedactionPolicy(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetLogRedactionPolicy")
	}
	return resp, nil
}

func (c *clientImpl) UpdateLogRedactionPolicy(
	ctx context.Context,
	in *globaldedicatedv1.UpdateLogRedactionPolicyRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.LogRedactionPolicy, error) {
	resp, err := c.clusterCli.UpdateLogRedactionPolicy(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateLogRedactionPolicy")
	}
	return resp, nil
}

func (c *clientImpl) BuildDesiredComponents(
	ctx context.Context,
	in *globaldedicatedv1.BuildDesiredComponentsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.BuildDesiredComponentsResponse, error) {
	resp, err := c.clusterCli.BuildDesiredComponents(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BuildDesiredComponents")
	}
	return resp, nil
}

func (c *clientImpl) AddSecondaryCidr(
	ctx context.Context,
	in *globaldedicatedv1.AddSecondaryCidrRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.Vpc, error) {
	resp, err := c.vpcCli.AddSecondaryCidr(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "AddSecondaryCidr")
	}
	return resp, nil
}

func (c *clientImpl) CreatePrivateLinkServiceMigration(
	ctx context.Context,
	in *globaldedicatedv1.CreatePrivateLinkServiceMigrationRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.PrivateLinkServiceMigration, error) {
	resp, err := c.privateLinkServiceMigrationCli.CreatePrivateLinkServiceMigration(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreatePrivateLinkServiceMigration")
	}
	return resp, nil
}

func (c *clientImpl) GetPrivateLinkServiceMigration(
	ctx context.Context,
	in *globaldedicatedv1.GetPrivateLinkServiceMigrationRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.PrivateLinkServiceMigration, error) {
	resp, err := c.privateLinkServiceMigrationCli.GetPrivateLinkServiceMigration(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetPrivateLinkServiceMigration")
	}
	return resp, nil
}

func (c *clientImpl) ListPrivateLinkServiceMigrations(
	ctx context.Context,
	in *globaldedicatedv1.ListPrivateLinkServiceMigrationsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListPrivateLinkServiceMigrationsResponse, error) {
	resp, err := c.privateLinkServiceMigrationCli.ListPrivateLinkServiceMigrations(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListPrivateLinkServiceMigrations")
	}
	return resp, nil
}

func (c *clientImpl) CancelPrivateLinkServiceMigration(
	ctx context.Context,
	in *globaldedicatedv1.CancelPrivateLinkServiceMigrationRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.privateLinkServiceMigrationCli.CancelPrivateLinkServiceMigration(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CancelPrivateLinkServiceMigration")
	}
	return resp, nil
}

func (c *clientImpl) GetClusterCustomParams(
	ctx context.Context,
	in *globaldedicatedv1.GetClusterCustomParamsRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.GetClusterCustomParamsResponse, error) {
	resp, err := c.clusterCli.GetClusterCustomParams(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetClusterCustomParams")
	}
	return resp, nil
}

func (c *clientImpl) SyncSystemVariables(
	ctx context.Context,
	in *globaldedicatedv1.SyncSystemVariablesRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.SyncSystemVariables(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "SyncSystemVariables")
	}
	return resp, nil
}

func (c *clientImpl) SyncPdOnlineConfig(
	ctx context.Context,
	in *globaldedicatedv1.SyncPdOnlineConfigRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.SyncPdOnlineConfig(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "SyncPdOnlineConfig")
	}
	return resp, nil
}

func (c *clientImpl) ShutdownUpgradeCluster(
	ctx context.Context,
	in *globaldedicatedv1.ShutdownUpgradeClusterRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.ShutdownUpgradeCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ShutdownUpgradeCluster")
	}
	return resp, nil
}

func (c *clientImpl) DisableTidbGroupDNS(
	ctx context.Context,
	in *globaldedicatedv1.DisableTidbGroupDNSRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.tidbGroupCli.DisableTidbGroupDNS(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DisableTidbGroupDNS")
	}
	return resp, nil
}

func (c *clientImpl) EnableTidbGroupDNS(
	ctx context.Context,
	in *globaldedicatedv1.EnableTidbGroupDNSRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.tidbGroupCli.EnableTidbGroupDNS(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "EnableTidbGroupDNS")
	}
	return resp, nil
}

func (c *clientImpl) GetPrivateLinkIPAddressType(
	ctx context.Context,
	in *globaldedicatedv1.GetPrivateLinkIPAddressTypeRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	resp, err := c.tidbGroupCli.GetPrivateLinkIPAddressType(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetPrivateLinkIPAddressType")
	}
	return resp, nil
}

func (c *clientImpl) SetPrivateLinkIPAddressType(
	ctx context.Context,
	in *globaldedicatedv1.SetPrivateLinkIPAddressTypeRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	resp, err := c.tidbGroupCli.SetPrivateLinkIPAddressType(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "SetPrivateLinkIPAddressType")
	}
	return resp, nil
}

func (c *clientImpl) EnableClusterConfigBackup(
	ctx context.Context,
	in *globaldedicatedv1.EnableClusterConfigBackupRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ClusterConfigBackupPolicy, error) {
	resp, err := c.clusterCli.EnableClusterConfigBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "EnableClusterConfigBackup")
	}
	return resp, nil
}

func (c *clientImpl) DisableClusterConfigBackup(
	ctx context.Context,
	in *globaldedicatedv1.DisableClusterConfigBackupRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ClusterConfigBackupPolicy, error) {
	resp, err := c.clusterCli.DisableClusterConfigBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DisableClusterConfigBackup")
	}
	return resp, nil
}

func (c *clientImpl) ListClusterConfigBackup(
	ctx context.Context,
	in *globaldedicatedv1.ListClusterConfigBackupRequest,
	opts ...grpc.CallOption,
) (*globaldedicatedv1.ListClusterConfigBackupResponse, error) {
	resp, err := c.clusterCli.ListClusterConfigBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListClusterConfigBackup")
	}
	return resp, nil
}