package globalnextgencli

import (
	"context"

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

	globalcommonv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	globalngv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/nextgen/v1"
	"github.com/tidbcloud/tidb-management-service/tidb-mgmt-service/domain/adapter/nextgenglobal"
	"github.com/tidbcloud/tidb-management-service/utilities/bizerr"
)

type clientImpl struct {
	clusterCli                   globalngv1.ClusterServiceClient
	byocVpcPeeringCli            globalngv1.ByocVpcPeeringServiceClient
	regionCli                    globalngv1.RegionServiceClient
	publicConnectionSettingCli   globalngv1.PublicConnectionSettingServiceClient
	privateEndpointConnectionCli globalngv1.PrivateLinkConnectionServiceClient
	backupCli                    globalngv1.BackupServiceClient
	exportCli                    globalngv1.ExportServiceClient
	auditlogCli                  globalngv1.DatabaseAuditLogServiceClient
	logRedactionPolicyCli        globalngv1.LogRedactionPolicyServiceClient
	planReplayerCli              globalngv1.PlanReplayerServiceClient
	resourcePoolCli              globalngv1.ResourcePoolServiceClient
	rcuQuotaCli                  globalngv1.RcuQuotaServiceClient
	cmekCli                      globalngv1.CustomerManagedEncryptionKeyServiceClient
	reservedCapacityTemplateCli  globalngv1.ReservedCapacityTemplateServiceClient
}

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

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

func (c *clientImpl) GetVpcPeeringAllowlistSetting(
	ctx context.Context,
	in *globalngv1.GetVpcPeeringAllowlistSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.VpcPeeringAllowlistSetting, error) {
	resp, err := c.byocVpcPeeringCli.GetVpcPeeringAllowlistSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetVpcPeeringAllowlistSetting")
	}
	return resp, nil
}

func (c *clientImpl) UpdateVpcPeeringAllowlistSetting(
	ctx context.Context,
	in *globalngv1.UpdateVpcPeeringAllowlistSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.VpcPeeringAllowlistSetting, error) {
	resp, err := c.byocVpcPeeringCli.UpdateVpcPeeringAllowlistSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateVpcPeeringAllowlistSetting")
	}
	return resp, nil
}

func (c *clientImpl) CreateCluster(
	ctx context.Context,
	in *globalngv1.CreateClusterRequest,
	opts ...grpc.CallOption,
) (*globalngv1.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 *globalngv1.ListClustersRequest,
	opts ...grpc.CallOption,
) (*globalngv1.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 *globalngv1.GetClusterRequest,
	opts ...grpc.CallOption,
) (*globalngv1.Cluster, error) {
	resp, err := c.clusterCli.GetCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCluster")
	}

	return resp, nil
}

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

	return resp, nil
}

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

	return resp, nil
}

func (c *clientImpl) EstimatePrice(
	ctx context.Context,
	in *globalngv1.EstimatePriceRequest,
	opts ...grpc.CallOption,
) (*globalngv1.EstimatePriceResponse, error) {
	resp, err := c.clusterCli.EstimatePrice(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "EstimatePrice")
	}

	return resp, nil
}

func (c *clientImpl) ChangeClusterPasswd(
	ctx context.Context,
	in *globalngv1.ChangeClusterPasswdRequest,
	opts ...grpc.CallOption,
) (*globalngv1.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) GetRegionByLogicalName(
	ctx context.Context,
	in *globalngv1.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 *globalngv1.ListRegionsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.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) UpdateRegionOpsAuditLogSetting(
	ctx context.Context,
	in *globalngv1.UpdateRegionOpsAuditLogSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.UpdateRegionOpsAuditLogSettingResponse, error) {
	resp, err := c.regionCli.UpdateRegionOpsAuditLogSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateRegionOpsAuditLogSetting")
	}

	return resp, nil
}

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

	return resp, nil
}

func (c *clientImpl) RegisterCloudProvider(
	ctx context.Context,
	in *globalngv1.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) RegisterRegion(
	ctx context.Context,
	in *globalngv1.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 *globalngv1.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) DeleteRegion(
	ctx context.Context,
	in *globalngv1.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
}

func (c *clientImpl) ListRegionCapacities(
	ctx context.Context,
	in *globalngv1.ListRegionCapacitiesRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListRegionCapacitiesResponse, error) {
	resp, err := c.regionCli.ListRegionCapacities(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListRegionCapacities")
	}

	return resp, nil
}

func (c *clientImpl) ListByocVcpuPools(
	ctx context.Context,
	in *globalngv1.ListByocVcpuPoolsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListByocVcpuPoolsResponse, error) {
	resp, err := c.regionCli.ListByocVcpuPools(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListByocVcpuPools")
	}

	return resp, nil
}

func (c *clientImpl) GetByocSharedComponentScaleConstraints(
	ctx context.Context,
	in *globalngv1.GetByocSharedComponentScaleConstraintsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ByocSharedComponentScaleConstraints, error) {
	resp, err := c.regionCli.GetByocSharedComponentScaleConstraints(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetByocSharedComponentScaleConstraints")
	}

	return resp, nil
}

func (c *clientImpl) ScaleByocSharedComponents(
	ctx context.Context,
	in *globalngv1.ScaleByocSharedComponentsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ScaleByocSharedComponentsResponse, error) {
	resp, err := c.regionCli.ScaleByocSharedComponents(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ScaleByocSharedComponents")
	}

	return resp, nil
}

func (c *clientImpl) ListNodeSpecs(
	ctx context.Context,
	in *globalngv1.ListNodeSpecsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListNodeSpecsResponse, error) {
	resp, err := c.regionCli.ListNodeSpecs(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListNodeSpecs")
	}

	return resp, nil
}

func (c *clientImpl) PlanResourcePoolCidr(
	ctx context.Context,
	in *globalngv1.PlanResourcePoolCidrRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PlanResourcePoolCidrResponse, error) {
	resp, err := c.regionCli.PlanResourcePoolCidr(ctx, in, opts...)
	if err != nil {
		return nil, normalizeResourcePoolCIDRRegionError(err, "PlanResourcePoolCidr")
	}
	return resp, nil
}

func (c *clientImpl) ValidateResourcePoolCidr(
	ctx context.Context,
	in *globalngv1.ValidateResourcePoolCidrRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ValidateResourcePoolCidrResponse, error) {
	resp, err := c.regionCli.ValidateResourcePoolCidr(ctx, in, opts...)
	if err != nil {
		return nil, normalizeResourcePoolCIDRRegionError(err, "ValidateResourcePoolCidr")
	}
	return resp, nil
}

func normalizeResourcePoolCIDRRegionError(err error, operation string) error {
	wrapped := bizerr.WrapGrpcError(err, "%s", operation)
	switch wrapped.ErrCode() {
	case bizerr.ErrCode(codes.Canceled),
		bizerr.ErrCode(codes.InvalidArgument),
		bizerr.ErrCode(codes.NotFound),
		bizerr.ErrCode(codes.ResourceExhausted),
		bizerr.ErrCode(codes.Internal),
		bizerr.ErrCode(codes.Unavailable):
		return wrapped
	default:
		return bizerr.New(bizerr.ErrCode(codes.Unavailable), "regional network validation is unavailable").Chain(operation)
	}
}

func (c *clientImpl) GetPublicConnectionSetting(
	ctx context.Context,
	in *globalngv1.GetPublicConnectionSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PublicConnectionSetting, error) {
	resp, err := c.publicConnectionSettingCli.GetPublicConnectionSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetPublicConnectionSetting")
	}

	return resp, nil
}

func (c *clientImpl) UpdatePublicConnectionSetting(
	ctx context.Context,
	in *globalngv1.UpdatePublicConnectionSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PublicConnectionSetting, error) {
	resp, err := c.publicConnectionSettingCli.UpdatePublicConnectionSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdatePublicConnectionSetting")
	}

	return resp, nil
}

func (c *clientImpl) CreatePrivateLinkConnection(
	ctx context.Context,
	in *globalngv1.CreatePrivateLinkConnectionRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PrivateLinkConnection, error) {
	resp, err := c.privateEndpointConnectionCli.CreatePrivateLinkConnection(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreatePrivateLinkConnection")
	}

	return resp, nil
}

func (c *clientImpl) GetPrivateLinkConnection(
	ctx context.Context,
	in *globalngv1.GetPrivateLinkConnectionRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PrivateLinkConnection, error) {
	resp, err := c.privateEndpointConnectionCli.GetPrivateLinkConnection(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetPrivateLinkConnection")
	}

	return resp, nil
}

func (c *clientImpl) DeletePrivateLinkConnection(
	ctx context.Context,
	in *globalngv1.DeletePrivateLinkConnectionRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PrivateLinkConnection, error) {
	resp, err := c.privateEndpointConnectionCli.DeletePrivateLinkConnection(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeletePrivateLinkConnection")
	}

	return resp, nil
}

func (c *clientImpl) ListPrivateLinkConnections(
	ctx context.Context,
	in *globalngv1.ListPrivateLinkConnectionsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListPrivateLinkConnectionsResponse, error) {
	resp, err := c.privateEndpointConnectionCli.ListPrivateLinkConnections(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListPrivateLinkConnections")
	}

	return resp, nil
}

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

	return resp, nil
}

func (c *clientImpl) ListPrivateLinkServices(
	ctx context.Context,
	in *globalngv1.ListPrivateLinkServicesRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListPrivateLinkServicesResponse, error) {
	resp, err := c.privateEndpointConnectionCli.ListPrivateLinkServices(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListPrivateLinkServices")
	}

	return resp, nil
}

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

func (c *clientImpl) GetProviderRole(
	ctx context.Context,
	in *globalngv1.GetProviderRoleRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ProviderRole, error) {
	resp, err := c.clusterCli.GetProviderRole(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetProviderRole")
	}

	return resp, nil
}

// DeleteClusterBackup implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) DeleteClusterBackup(
	ctx context.Context,
	in *globalngv1.DeleteClusterBackupRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.DeleteClusterBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteClusterBackup")
	}
	return resp, nil
}

// ListClusterBackups implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) ListClusterBackups(
	ctx context.Context,
	in *globalngv1.ListClusterBackupsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListClusterBackupsResponse, error) {
	resp, err := c.clusterCli.ListClusterBackups(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListClusterBackups")
	}
	return resp, nil
}

// RestoreCluster implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) RestoreCluster(
	ctx context.Context,
	in *globalngv1.RestoreClusterRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.clusterCli.RestoreCluster(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RestoreCluster")
	}
	return resp, nil
}

// TestClassicBackupAccess implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) TestClassicBackupAccess(
	ctx context.Context,
	in *globalngv1.TestClassicBackupAccessRequest,
	opts ...grpc.CallOption,
) (*globalngv1.TestClassicBackupAccessResponse, error) {
	resp, err := c.clusterCli.TestClassicBackupAccess(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "TestClassicBackupAccess")
	}
	return resp, nil
}

// RestoreStatus implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) RestoreStatus(
	ctx context.Context,
	in *globalngv1.RestoreStatusRequest,
	opts ...grpc.CallOption,
) (*globalngv1.RestoreStatusResponse, error) {
	resp, err := c.clusterCli.RestoreStatus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RestoreStatus")
	}
	return resp, nil
}

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

func (c *clientImpl) GetBackupSetting(
	ctx context.Context,
	in *globalngv1.GetBackupSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.BackupSetting, error) {
	resp, err := c.clusterCli.GetBackupSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetBackupSetting")
	}
	return resp, nil
}

func (c *clientImpl) UpdateBackupSetting(
	ctx context.Context,
	in *globalngv1.UpdateBackupSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.BackupSetting, error) {
	resp, err := c.clusterCli.UpdateBackupSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateBackupSetting")
	}
	return resp, nil
}

// DeleteBackup implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) DeleteBackup(
	ctx context.Context,
	in *globalngv1.DeleteBackupRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.backupCli.DeleteBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteBackup")
	}
	return resp, nil
}

// CreateManualBackup implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) CreateManualBackup(
	ctx context.Context,
	in *globalngv1.CreateManualBackupRequest,
	opts ...grpc.CallOption,
) (*globalngv1.CreateManualBackupResponse, error) {
	resp, err := c.backupCli.CreateManualBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateManualBackup")
	}
	return resp, nil
}

// CreateFinalBackup implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) CreateFinalBackup(
	ctx context.Context,
	in *globalngv1.CreateFinalBackupRequest,
	opts ...grpc.CallOption,
) (*globalngv1.CreateFinalBackupResponse, error) {
	resp, err := c.backupCli.CreateFinalBackup(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateFinalBackup")
	}
	return resp, nil
}

// ListBackups implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) ListBackups(
	ctx context.Context,
	in *globalngv1.ListBackupsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListBackupsResponse, error) {
	resp, err := c.backupCli.ListBackups(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListBackups")
	}
	return resp, nil
}

// ListExports implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) ListExports(
	ctx context.Context,
	in *globalngv1.ListExportsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListExportsResponse, error) {
	resp, err := c.exportCli.ListExports(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListExports")
	}
	return resp, nil
}

// GetExport implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) GetExport(
	ctx context.Context,
	in *globalngv1.GetExportRequest,
	opts ...grpc.CallOption,
) (*globalngv1.Export, error) {
	resp, err := c.exportCli.GetExport(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetExport")
	}
	return resp, nil
}

// CreateExport implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) CreateExport(
	ctx context.Context,
	in *globalngv1.CreateExportRequest,
	opts ...grpc.CallOption,
) (*globalngv1.Export, error) {
	resp, err := c.exportCli.CreateExport(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateExport")
	}
	return resp, nil
}

// DeleteExport implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) DeleteExport(
	ctx context.Context,
	in *globalngv1.DeleteExportRequest,
	opts ...grpc.CallOption,
) (*globalngv1.Export, error) {
	resp, err := c.exportCli.DeleteExport(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteExport")
	}
	return resp, nil
}

// CancelExport implements nextgenglobal.NextGenGlobal.
func (c *clientImpl) CancelExport(
	ctx context.Context,
	in *globalngv1.CancelExportRequest,
	opts ...grpc.CallOption,
) (*globalngv1.Export, error) {
	resp, err := c.exportCli.CancelExport(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CancelExport")
	}
	return resp, nil
}

func (c *clientImpl) ListNotCleanupBackupSettings(
	ctx context.Context,
	in *globalngv1.ListNotCleanupBackupSettingsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListNotCleanupBackupSettingsResponse, error) {
	resp, err := c.backupCli.ListNotCleanupBackupSettings(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListNotCleanupBackupSettings")
	}
	return resp, nil
}

func (c *clientImpl) OverrideFlexibleBackupRetention(
	ctx context.Context,
	in *globalngv1.OverrideFlexibleBackupRetentionRequest,
	opts ...grpc.CallOption,
) (*globalngv1.BackupSetting, error) {
	resp, err := c.backupCli.OverrideFlexibleBackupRetention(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "OverrideFlexibleBackupRetention")
	}
	return resp, nil
}

func (c *clientImpl) BatchUpdateBackupSettingNames(
	ctx context.Context,
	in *globalngv1.BatchUpdateBackupSettingNamesRequest,
	opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
	resp, err := c.backupCli.BatchUpdateBackupSettingNames(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BatchUpdateBackupSettingNames")
	}
	return resp, nil
}

func (c *clientImpl) ListBackupPolicies(
	ctx context.Context,
	in *globalngv1.ListBackupPoliciesRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListBackupPoliciesResponse, error) {
	resp, err := c.backupCli.ListBackupPolicies(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListBackupPolicies")
	}
	return resp, nil
}

func (c *clientImpl) UpdateAuditLogSetting(
	ctx context.Context,
	in *globalngv1.UpdateAuditLogSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.AuditLogSetting, error) {
	resp, err := c.auditlogCli.UpdateAuditLogSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateAuditLogSetting")
	}
	return resp, nil
}

func (c *clientImpl) GetAuditLogSetting(
	ctx context.Context,
	in *globalngv1.GetAuditLogSettingRequest,
	opts ...grpc.CallOption,
) (*globalngv1.AuditLogSetting, error) {
	resp, err := c.auditlogCli.GetAuditLogSetting(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetAuditLogSetting")
	}
	return resp, nil
}

func (c *clientImpl) ListAuditLogFilterRules(
	ctx context.Context,
	in *globalngv1.ListAuditLogFilterRulesRequest,
	opts ...grpc.CallOption,
) (*globalngv1.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 *globalngv1.CreateAuditLogFilterRuleRequest,
	opts ...grpc.CallOption,
) (*globalngv1.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 *globalngv1.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) UpdateAuditLogFilterRule(
	ctx context.Context,
	in *globalngv1.UpdateAuditLogFilterRuleRequest,
	opts ...grpc.CallOption,
) (*globalngv1.AuditLogFilterRule, error) {
	resp, err := c.auditlogCli.UpdateAuditLogFilterRule(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateAuditLogFilterRule")
	}
	return resp, nil
}

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

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

func (c *clientImpl) GetPlanReplayerStatus(
	ctx context.Context,
	in *globalngv1.GetPlanReplayerStatusRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PlanReplayerStatus, error) {
	resp, err := c.planReplayerCli.GetPlanReplayerStatus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetPlanReplayerStatus")
	}
	return resp, nil
}

func (c *clientImpl) UpdatePlanReplayerStatus(
	ctx context.Context,
	in *globalngv1.UpdatePlanReplayerStatusRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PlanReplayerStatus, error) {
	resp, err := c.planReplayerCli.UpdatePlanReplayerStatus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdatePlanReplayerStatus")
	}
	return resp, nil
}

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

func (c *clientImpl) SelectRegionByOrgId(
	ctx context.Context,
	in *globalngv1.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) CreateResourcePool(
	ctx context.Context,
	in *globalngv1.CreateResourcePoolRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePoolProfile, error) {
	resp, err := c.resourcePoolCli.CreateResourcePool(ctx, in, opts...)
	if err != nil {
		if cidrStatus := nextgenglobal.NewCIDRValidationStatusError(err); cidrStatus != nil {
			return nil, cidrStatus
		}
		return nil, bizerr.WrapGrpcError(err, "CreateResourcePool")
	}
	return resp, nil
}

func (c *clientImpl) ListResourcePools(
	ctx context.Context,
	in *globalngv1.ListResourcePoolsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListResourcePoolsResponse, error) {
	resp, err := c.resourcePoolCli.ListResourcePools(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListResourcePools")
	}
	return resp, nil
}

func (c *clientImpl) GetResourcePool(
	ctx context.Context,
	in *globalngv1.GetResourcePoolRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePoolProfile, error) {
	resp, err := c.resourcePoolCli.GetResourcePool(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetResourcePool")
	}
	return resp, nil
}

func (c *clientImpl) UpdateResourcePoolName(
	ctx context.Context,
	in *globalngv1.UpdateResourcePoolNameRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePool, error) {
	resp, err := c.resourcePoolCli.UpdateResourcePoolName(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateResourcePoolName")
	}
	return resp, nil
}

func (c *clientImpl) UpdateResourcePoolInstanceLimit(
	ctx context.Context,
	in *globalngv1.UpdateResourcePoolInstanceLimitRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePool, error) {
	resp, err := c.resourcePoolCli.UpdateResourcePoolInstanceLimit(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateResourcePoolInstanceLimit")
	}
	return resp, nil
}

func (c *clientImpl) DeleteResourcePool(
	ctx context.Context,
	in *globalngv1.DeleteResourcePoolRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePool, error) {
	resp, err := c.resourcePoolCli.DeleteResourcePool(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteResourcePool")
	}
	return resp, nil
}

func (c *clientImpl) ListOwnerResourcePools(
	ctx context.Context,
	in *globalngv1.ListOwnerResourcePoolsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ListOwnerResourcePoolsResponse, error) {
	resp, err := c.resourcePoolCli.ListOwnerResourcePools(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListOwnerResourcePools")
	}
	return resp, nil
}

func (c *clientImpl) UpdateOrgDefaultResourcePool(
	ctx context.Context,
	in *globalngv1.UpdateOrgDefaultResourcePoolRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePoolStrategy, error) {
	resp, err := c.resourcePoolCli.UpdateOrgDefaultResourcePool(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateOrgDefaultResourcePool")
	}
	return resp, nil
}

func (c *clientImpl) GetResourcePoolCapacityConstraints(
	ctx context.Context,
	in *globalngv1.GetResourcePoolCapacityConstraintsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePoolCapacityConstraints, error) {
	resp, err := c.resourcePoolCli.GetResourcePoolCapacityConstraints(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetResourcePoolCapacityConstraints")
	}

	return resp, nil
}

func (c *clientImpl) ResizeResourcePoolCapacity(
	ctx context.Context,
	in *globalngv1.ResizeResourcePoolCapacityRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResizeResourcePoolCapacityResponse, error) {
	resp, err := c.resourcePoolCli.ResizeResourcePoolCapacity(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ResizeResourcePoolCapacity")
	}

	return resp, nil
}

func (c *clientImpl) UpsertResourcePoolCloudResourceTags(
	ctx context.Context,
	in *globalngv1.UpsertResourcePoolCloudResourceTagsRequest,
	opts ...grpc.CallOption,
) (*globalngv1.UpsertResourcePoolCloudResourceTagsResponse, error) {
	resp, err := c.resourcePoolCli.UpsertResourcePoolCloudResourceTags(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpsertResourcePoolCloudResourceTags")
	}

	return resp, nil
}

func (c *clientImpl) PauseResourcePool(
	ctx context.Context,
	in *globalngv1.PauseResourcePoolRequest,
	opts ...grpc.CallOption,
) (*globalngv1.PauseResourcePoolResponse, error) {
	resp, err := c.resourcePoolCli.PauseResourcePool(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "PauseResourcePool")
	}
	return resp, nil
}

func (c *clientImpl) BeginPauseResourcePoolAdmission(
	ctx context.Context,
	in *globalngv1.BeginPauseResourcePoolAdmissionRequest,
	opts ...grpc.CallOption,
) (*globalngv1.BeginPauseResourcePoolAdmissionResponse, error) {
	resp, err := c.resourcePoolCli.BeginPauseResourcePoolAdmission(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "BeginPauseResourcePoolAdmission")
	}
	return resp, nil
}

func (c *clientImpl) ResolvePauseResourcePoolAdmission(
	ctx context.Context,
	in *globalngv1.ResolvePauseResourcePoolAdmissionRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResolvePauseResourcePoolAdmissionResponse, error) {
	resp, err := c.resourcePoolCli.ResolvePauseResourcePoolAdmission(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ResolvePauseResourcePoolAdmission")
	}
	return resp, nil
}

func (c *clientImpl) ResumeResourcePool(
	ctx context.Context,
	in *globalngv1.ResumeResourcePoolRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResumeResourcePoolResponse, error) {
	resp, err := c.resourcePoolCli.ResumeResourcePool(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ResumeResourcePool")
	}
	return resp, nil
}

func (c *clientImpl) GetResourcePoolPauseResumeOperation(
	ctx context.Context,
	in *globalngv1.GetResourcePoolPauseResumeOperationRequest,
	opts ...grpc.CallOption,
) (*globalngv1.ResourcePoolPauseResumeOperation, error) {
	resp, err := c.resourcePoolCli.GetResourcePoolPauseResumeOperation(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetResourcePoolPauseResumeOperation")
	}
	return resp, nil
}

func (c *clientImpl) GetRcuQuota(ctx context.Context,
	in *globalngv1.GetRcuQuotaRequest,
	opts ...grpc.CallOption) (*globalngv1.RcuQuota, error) {
	resp, err := c.rcuQuotaCli.GetRcuQuota(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetRcuQuota")
	}
	return resp, nil
}

func (c *clientImpl) CalculateMinRcu(ctx context.Context,
	in *globalngv1.CalculateMinRcuRequest,
	opts ...grpc.CallOption) (*globalngv1.CalculateMinRcuResponse, error) {
	resp, err := c.rcuQuotaCli.CalculateMinRcu(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CalculateMinRcu")
	}
	return resp, nil
}

func (c *clientImpl) ListOrgRcuQuotas(ctx context.Context,
	in *globalngv1.ListOrgRcuQuotasRequest,
	opts ...grpc.CallOption) (*globalngv1.ListOrgRcuQuotasResponse, error) {
	resp, err := c.rcuQuotaCli.ListOrgRcuQuotas(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListOrgRcuQuotas")
	}
	return resp, nil
}

func (c *clientImpl) UpdateRcuQuota(ctx context.Context,
	in *globalngv1.UpdateRcuQuotaRequest,
	opts ...grpc.CallOption) (*globalngv1.RcuQuota, error) {
	resp, err := c.rcuQuotaCli.UpdateRcuQuota(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateRcuQuota")
	}
	return resp, nil
}

func (c *clientImpl) CreateReservedCapacityTemplate(ctx context.Context,
	in *globalngv1.CreateReservedCapacityTemplateRequest,
	opts ...grpc.CallOption) (*globalngv1.ReservedCapacityTemplate, error) {
	resp, err := c.reservedCapacityTemplateCli.CreateReservedCapacityTemplate(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "CreateReservedCapacityTemplate")
	}
	return resp, nil
}

func (c *clientImpl) GetReservedCapacityTemplate(ctx context.Context,
	in *globalngv1.GetReservedCapacityTemplateRequest,
	opts ...grpc.CallOption) (*globalngv1.ReservedCapacityTemplate, error) {
	resp, err := c.reservedCapacityTemplateCli.GetReservedCapacityTemplate(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetReservedCapacityTemplate")
	}
	return resp, nil
}

func (c *clientImpl) ListReservedCapacityTemplates(ctx context.Context,
	in *globalngv1.ListReservedCapacityTemplatesRequest,
	opts ...grpc.CallOption) (*globalngv1.ListReservedCapacityTemplatesResponse, error) {
	resp, err := c.reservedCapacityTemplateCli.ListReservedCapacityTemplates(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListReservedCapacityTemplates")
	}
	return resp, nil
}

func (c *clientImpl) UpdateReservedCapacityTemplateStatus(ctx context.Context,
	in *globalngv1.UpdateReservedCapacityTemplateStatusRequest,
	opts ...grpc.CallOption) (*globalngv1.ReservedCapacityTemplate, error) {
	resp, err := c.reservedCapacityTemplateCli.UpdateReservedCapacityTemplateStatus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateReservedCapacityTemplateStatus")
	}
	return resp, nil
}

func (c *clientImpl) DeleteReservedCapacityTemplate(ctx context.Context,
	in *globalngv1.DeleteReservedCapacityTemplateRequest,
	opts ...grpc.CallOption) (*emptypb.Empty, error) {
	resp, err := c.reservedCapacityTemplateCli.DeleteReservedCapacityTemplate(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "DeleteReservedCapacityTemplate")
	}
	return resp, nil
}

func (c *clientImpl) GetCaCertificateDownloadUrl(ctx context.Context,
	in *globalngv1.GetCaCertificateDownloadUrlRequest, opts ...grpc.CallOption,
) (*globalngv1.CaCertificateDownloadUrl, error) {
	resp, err := c.clusterCli.GetCaCertificateDownloadUrl(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCaCertificateDownloadUrl")
	}
	return resp, nil
}

func (c *clientImpl) RegisterRegionProviderIdentity(ctx context.Context,
	in *globalngv1.RegisterRegionProviderIdentityRequest, opts ...grpc.CallOption,
) (*globalngv1.RegionProviderIdentity, error) {
	resp, err := c.regionCli.RegisterRegionProviderIdentity(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "RegisterRegionProviderIdentity")
	}
	return resp, nil
}

func (c *clientImpl) ListRegionProviderIdentities(ctx context.Context,
	in *globalngv1.ListRegionProviderIdentitiesRequest, opts ...grpc.CallOption,
) (*globalngv1.ListRegionProviderIdentitiesResponse, error) {
	resp, err := c.regionCli.ListRegionProviderIdentities(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "ListRegionProviderIdentities")
	}
	return resp, nil
}

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

func (c *clientImpl) VerifyCmekAccessIamPrincipal(ctx context.Context,
	in *globalngv1.VerifyCmekAccessIamPrincipalRequest, opts ...grpc.CallOption,
) (*globalngv1.VerifyCmekAccessIamPrincipalResponse, error) {
	resp, err := c.cmekCli.VerifyCmekAccessIamPrincipal(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "VerifyCmekAccessIamPrincipal")
	}
	return resp, nil
}

func (c *clientImpl) GetCustomerManagedEncryptionKey(ctx context.Context,
	in *globalngv1.GetCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption,
) (*globalngv1.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) GetCustomerManagedEncryptionKeyByClusterId(ctx context.Context,
	in *globalngv1.GetCustomerManagedEncryptionKeyByClusterIdRequest, opts ...grpc.CallOption,
) (*globalngv1.CustomerManagedEncryptionKey, error) {
	resp, err := c.cmekCli.GetCustomerManagedEncryptionKeyByClusterId(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetCustomerManagedEncryptionKeyByClusterId")
	}
	return resp, nil
}

func (c *clientImpl) ListCustomerManagedEncryptionKeys(ctx context.Context,
	in *globalngv1.ListCustomerManagedEncryptionKeysRequest, opts ...grpc.CallOption,
) (*globalngv1.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) UpdateClusterProject(
	ctx context.Context,
	in *globalngv1.UpdateClusterProjectRequest,
	opts ...grpc.CallOption,
) (*globalngv1.UpdateClusterProjectResponse, error) {
	resp, err := c.clusterCli.UpdateClusterProject(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateClusterProject")
	}
	return resp, nil
}

func (c *clientImpl) UpdateClusterDualLayerEncryption(ctx context.Context,
	in *globalngv1.UpdateClusterDualLayerEncryptionRequest, opts ...grpc.CallOption,
) (*globalngv1.UpdateClusterDualLayerEncryptionResponse, error) {
	resp, err := c.clusterCli.UpdateClusterDualLayerEncryption(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "UpdateClusterDualLayerEncryption")
	}
	return resp, nil
}

func (c *clientImpl) GetClusterEncryptionStatus(ctx context.Context,
	in *globalngv1.GetClusterEncryptionStatusRequest, opts ...grpc.CallOption,
) (*globalngv1.ClusterEncryptionStatus, error) {
	resp, err := c.clusterCli.GetClusterEncryptionStatus(ctx, in, opts...)
	if err != nil {
		return nil, bizerr.WrapGrpcError(err, "GetClusterEncryptionStatus")
	}
	return resp, nil
}

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