// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.4.0
// - protoc             (unknown)
// source: global/dedicated/v1/services.proto

package dedicatedv1

import (
	context "context"
	v1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.62.0 or later.
const _ = grpc.SupportPackageIsVersion8

const (
	ClusterService_CreateCluster_FullMethodName                  = "/global.dedicated.v1.ClusterService/CreateCluster"
	ClusterService_ListClusters_FullMethodName                   = "/global.dedicated.v1.ClusterService/ListClusters"
	ClusterService_GetCluster_FullMethodName                     = "/global.dedicated.v1.ClusterService/GetCluster"
	ClusterService_DeleteCluster_FullMethodName                  = "/global.dedicated.v1.ClusterService/DeleteCluster"
	ClusterService_ScaleCluster_FullMethodName                   = "/global.dedicated.v1.ClusterService/ScaleCluster"
	ClusterService_ScaleClusterWithMultiComponent_FullMethodName = "/global.dedicated.v1.ClusterService/ScaleClusterWithMultiComponent"
	ClusterService_PauseCluster_FullMethodName                   = "/global.dedicated.v1.ClusterService/PauseCluster"
	ClusterService_ResumeCluster_FullMethodName                  = "/global.dedicated.v1.ClusterService/ResumeCluster"
	ClusterService_GetComponentNodeInfo_FullMethodName           = "/global.dedicated.v1.ClusterService/GetComponentNodeInfo"
	ClusterService_SetClientCaCertificate_FullMethodName         = "/global.dedicated.v1.ClusterService/SetClientCaCertificate"
	ClusterService_GetClientCaCertificate_FullMethodName         = "/global.dedicated.v1.ClusterService/GetClientCaCertificate"
	ClusterService_ApplyCluster_FullMethodName                   = "/global.dedicated.v1.ClusterService/ApplyCluster"
	ClusterService_ApplyGKEHeterogeneousDeploy_FullMethodName    = "/global.dedicated.v1.ClusterService/ApplyGKEHeterogeneousDeploy"
	ClusterService_GetGKEHeterogeneousDeploy_FullMethodName      = "/global.dedicated.v1.ClusterService/GetGKEHeterogeneousDeploy"
	ClusterService_DeleteGKEHeterogeneousDeploy_FullMethodName   = "/global.dedicated.v1.ClusterService/DeleteGKEHeterogeneousDeploy"
	ClusterService_GetBillableClustersCount_FullMethodName       = "/global.dedicated.v1.ClusterService/GetBillableClustersCount"
	ClusterService_GetClusterConfidentialInfo_FullMethodName     = "/global.dedicated.v1.ClusterService/GetClusterConfidentialInfo"
	ClusterService_CreateClusterSnapshot_FullMethodName          = "/global.dedicated.v1.ClusterService/CreateClusterSnapshot"
	ClusterService_ListClusterSnapshots_FullMethodName           = "/global.dedicated.v1.ClusterService/ListClusterSnapshots"
	ClusterService_ListTenantQuota_FullMethodName                = "/global.dedicated.v1.ClusterService/ListTenantQuota"
	ClusterService_UpdateTenantQuota_FullMethodName              = "/global.dedicated.v1.ClusterService/UpdateTenantQuota"
	ClusterService_ChangeClusterPasswd_FullMethodName            = "/global.dedicated.v1.ClusterService/ChangeClusterPasswd"
	ClusterService_GetDefaultTidbVersion_FullMethodName          = "/global.dedicated.v1.ClusterService/GetDefaultTidbVersion"
	ClusterService_GetLogRedactionPolicy_FullMethodName          = "/global.dedicated.v1.ClusterService/GetLogRedactionPolicy"
	ClusterService_UpdateLogRedactionPolicy_FullMethodName       = "/global.dedicated.v1.ClusterService/UpdateLogRedactionPolicy"
	ClusterService_BuildDesiredComponents_FullMethodName         = "/global.dedicated.v1.ClusterService/BuildDesiredComponents"
	ClusterService_GetClusterCustomParams_FullMethodName         = "/global.dedicated.v1.ClusterService/GetClusterCustomParams"
	ClusterService_SyncSystemVariables_FullMethodName            = "/global.dedicated.v1.ClusterService/SyncSystemVariables"
	ClusterService_SyncPdOnlineConfig_FullMethodName             = "/global.dedicated.v1.ClusterService/SyncPdOnlineConfig"
	ClusterService_ShutdownUpgradeCluster_FullMethodName         = "/global.dedicated.v1.ClusterService/ShutdownUpgradeCluster"
	ClusterService_EnableClusterConfigBackup_FullMethodName      = "/global.dedicated.v1.ClusterService/EnableClusterConfigBackup"
	ClusterService_DisableClusterConfigBackup_FullMethodName     = "/global.dedicated.v1.ClusterService/DisableClusterConfigBackup"
	ClusterService_ListClusterConfigBackup_FullMethodName        = "/global.dedicated.v1.ClusterService/ListClusterConfigBackup"
)

// ClusterServiceClient is the client API for ClusterService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ClusterServiceClient interface {
	CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error)
	GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	// DeleteCluster deletes the cluster but keeps the backup records. The cluster can be restored from the backup.
	DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	ScaleCluster(ctx context.Context, in *ScaleClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	ScaleClusterWithMultiComponent(ctx context.Context, in *ScaleClusterWithMultiComponentRequest, opts ...grpc.CallOption) (*Cluster, error)
	PauseCluster(ctx context.Context, in *PauseClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	ResumeCluster(ctx context.Context, in *ResumeClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	GetComponentNodeInfo(ctx context.Context, in *GetComponentNodeInfoRequest, opts ...grpc.CallOption) (*GetComponentNodeInfoResponse, error)
	SetClientCaCertificate(ctx context.Context, in *SetClientCaCertificateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetClientCaCertificate(ctx context.Context, in *GetClientCaCertificateRequest, opts ...grpc.CallOption) (*GetClientCaCertificateResponse, error)
	ApplyCluster(ctx context.Context, in *ApplyClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	ApplyGKEHeterogeneousDeploy(ctx context.Context, in *ApplyGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*GKEHeterogeneousDeploy, error)
	GetGKEHeterogeneousDeploy(ctx context.Context, in *GetGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*GKEHeterogeneousDeploy, error)
	DeleteGKEHeterogeneousDeploy(ctx context.Context, in *DeleteGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetBillableClustersCount(ctx context.Context, in *GetBillableClustersCountRequest, opts ...grpc.CallOption) (*GetBillableClustersCountResponse, error)
	GetClusterConfidentialInfo(ctx context.Context, in *GetClusterConfidentialInfoRequest, opts ...grpc.CallOption) (*GetClusterConfidentialInfoResponse, error)
	CreateClusterSnapshot(ctx context.Context, in *CreateClusterSnapshotRequest, opts ...grpc.CallOption) (*CreateClusterSnapshotResponse, error)
	ListClusterSnapshots(ctx context.Context, in *ListClusterSnapshotsRequest, opts ...grpc.CallOption) (*ListClusterSnapshotsResponse, error)
	ListTenantQuota(ctx context.Context, in *ListTenantQuotaRequest, opts ...grpc.CallOption) (*ListTenantQuotaResponse, error)
	UpdateTenantQuota(ctx context.Context, in *UpdateTenantQuotaRequest, opts ...grpc.CallOption) (*UpdateTenantQuotaResponse, error)
	ChangeClusterPasswd(ctx context.Context, in *ChangeClusterPasswdRequest, opts ...grpc.CallOption) (*ChangeClusterPasswdResponse, error)
	GetDefaultTidbVersion(ctx context.Context, in *GetDefaultTidbVersionRequest, opts ...grpc.CallOption) (*GetDefaultTidbVersionResponse, error)
	GetLogRedactionPolicy(ctx context.Context, in *GetLogRedactionPolicyRequest, opts ...grpc.CallOption) (*LogRedactionPolicy, error)
	UpdateLogRedactionPolicy(ctx context.Context, in *UpdateLogRedactionPolicyRequest, opts ...grpc.CallOption) (*LogRedactionPolicy, error)
	// BuildDesiredComponents builds the desired components for a cluster based on the provided parameters.
	// It returns the current and desired components, and also the default components derived from SKUs.
	// One can use this RPC to diff component changes.
	BuildDesiredComponents(ctx context.Context, in *BuildDesiredComponentsRequest, opts ...grpc.CallOption) (*BuildDesiredComponentsResponse, error)
	GetClusterCustomParams(ctx context.Context, in *GetClusterCustomParamsRequest, opts ...grpc.CallOption) (*GetClusterCustomParamsResponse, error)
	SyncSystemVariables(ctx context.Context, in *SyncSystemVariablesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	SyncPdOnlineConfig(ctx context.Context, in *SyncPdOnlineConfigRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ShutdownUpgradeCluster(ctx context.Context, in *ShutdownUpgradeClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	EnableClusterConfigBackup(ctx context.Context, in *EnableClusterConfigBackupRequest, opts ...grpc.CallOption) (*ClusterConfigBackupPolicy, error)
	DisableClusterConfigBackup(ctx context.Context, in *DisableClusterConfigBackupRequest, opts ...grpc.CallOption) (*ClusterConfigBackupPolicy, error)
	ListClusterConfigBackup(ctx context.Context, in *ListClusterConfigBackupRequest, opts ...grpc.CallOption) (*ListClusterConfigBackupResponse, error)
}

type clusterServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewClusterServiceClient(cc grpc.ClientConnInterface) ClusterServiceClient {
	return &clusterServiceClient{cc}
}

func (c *clusterServiceClient) CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_CreateCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListClustersResponse)
	err := c.cc.Invoke(ctx, ClusterService_ListClusters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_GetCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_DeleteCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ScaleCluster(ctx context.Context, in *ScaleClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_ScaleCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ScaleClusterWithMultiComponent(ctx context.Context, in *ScaleClusterWithMultiComponentRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_ScaleClusterWithMultiComponent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) PauseCluster(ctx context.Context, in *PauseClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_PauseCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ResumeCluster(ctx context.Context, in *ResumeClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_ResumeCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetComponentNodeInfo(ctx context.Context, in *GetComponentNodeInfoRequest, opts ...grpc.CallOption) (*GetComponentNodeInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetComponentNodeInfoResponse)
	err := c.cc.Invoke(ctx, ClusterService_GetComponentNodeInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) SetClientCaCertificate(ctx context.Context, in *SetClientCaCertificateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ClusterService_SetClientCaCertificate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetClientCaCertificate(ctx context.Context, in *GetClientCaCertificateRequest, opts ...grpc.CallOption) (*GetClientCaCertificateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetClientCaCertificateResponse)
	err := c.cc.Invoke(ctx, ClusterService_GetClientCaCertificate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ApplyCluster(ctx context.Context, in *ApplyClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_ApplyCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ApplyGKEHeterogeneousDeploy(ctx context.Context, in *ApplyGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*GKEHeterogeneousDeploy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GKEHeterogeneousDeploy)
	err := c.cc.Invoke(ctx, ClusterService_ApplyGKEHeterogeneousDeploy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetGKEHeterogeneousDeploy(ctx context.Context, in *GetGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*GKEHeterogeneousDeploy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GKEHeterogeneousDeploy)
	err := c.cc.Invoke(ctx, ClusterService_GetGKEHeterogeneousDeploy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) DeleteGKEHeterogeneousDeploy(ctx context.Context, in *DeleteGKEHeterogeneousDeployRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ClusterService_DeleteGKEHeterogeneousDeploy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetBillableClustersCount(ctx context.Context, in *GetBillableClustersCountRequest, opts ...grpc.CallOption) (*GetBillableClustersCountResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetBillableClustersCountResponse)
	err := c.cc.Invoke(ctx, ClusterService_GetBillableClustersCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetClusterConfidentialInfo(ctx context.Context, in *GetClusterConfidentialInfoRequest, opts ...grpc.CallOption) (*GetClusterConfidentialInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetClusterConfidentialInfoResponse)
	err := c.cc.Invoke(ctx, ClusterService_GetClusterConfidentialInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) CreateClusterSnapshot(ctx context.Context, in *CreateClusterSnapshotRequest, opts ...grpc.CallOption) (*CreateClusterSnapshotResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateClusterSnapshotResponse)
	err := c.cc.Invoke(ctx, ClusterService_CreateClusterSnapshot_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ListClusterSnapshots(ctx context.Context, in *ListClusterSnapshotsRequest, opts ...grpc.CallOption) (*ListClusterSnapshotsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListClusterSnapshotsResponse)
	err := c.cc.Invoke(ctx, ClusterService_ListClusterSnapshots_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ListTenantQuota(ctx context.Context, in *ListTenantQuotaRequest, opts ...grpc.CallOption) (*ListTenantQuotaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTenantQuotaResponse)
	err := c.cc.Invoke(ctx, ClusterService_ListTenantQuota_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) UpdateTenantQuota(ctx context.Context, in *UpdateTenantQuotaRequest, opts ...grpc.CallOption) (*UpdateTenantQuotaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateTenantQuotaResponse)
	err := c.cc.Invoke(ctx, ClusterService_UpdateTenantQuota_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ChangeClusterPasswd(ctx context.Context, in *ChangeClusterPasswdRequest, opts ...grpc.CallOption) (*ChangeClusterPasswdResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ChangeClusterPasswdResponse)
	err := c.cc.Invoke(ctx, ClusterService_ChangeClusterPasswd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetDefaultTidbVersion(ctx context.Context, in *GetDefaultTidbVersionRequest, opts ...grpc.CallOption) (*GetDefaultTidbVersionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetDefaultTidbVersionResponse)
	err := c.cc.Invoke(ctx, ClusterService_GetDefaultTidbVersion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetLogRedactionPolicy(ctx context.Context, in *GetLogRedactionPolicyRequest, opts ...grpc.CallOption) (*LogRedactionPolicy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LogRedactionPolicy)
	err := c.cc.Invoke(ctx, ClusterService_GetLogRedactionPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) UpdateLogRedactionPolicy(ctx context.Context, in *UpdateLogRedactionPolicyRequest, opts ...grpc.CallOption) (*LogRedactionPolicy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LogRedactionPolicy)
	err := c.cc.Invoke(ctx, ClusterService_UpdateLogRedactionPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) BuildDesiredComponents(ctx context.Context, in *BuildDesiredComponentsRequest, opts ...grpc.CallOption) (*BuildDesiredComponentsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BuildDesiredComponentsResponse)
	err := c.cc.Invoke(ctx, ClusterService_BuildDesiredComponents_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) GetClusterCustomParams(ctx context.Context, in *GetClusterCustomParamsRequest, opts ...grpc.CallOption) (*GetClusterCustomParamsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetClusterCustomParamsResponse)
	err := c.cc.Invoke(ctx, ClusterService_GetClusterCustomParams_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) SyncSystemVariables(ctx context.Context, in *SyncSystemVariablesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ClusterService_SyncSystemVariables_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) SyncPdOnlineConfig(ctx context.Context, in *SyncPdOnlineConfigRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ClusterService_SyncPdOnlineConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ShutdownUpgradeCluster(ctx context.Context, in *ShutdownUpgradeClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ClusterService_ShutdownUpgradeCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) EnableClusterConfigBackup(ctx context.Context, in *EnableClusterConfigBackupRequest, opts ...grpc.CallOption) (*ClusterConfigBackupPolicy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClusterConfigBackupPolicy)
	err := c.cc.Invoke(ctx, ClusterService_EnableClusterConfigBackup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) DisableClusterConfigBackup(ctx context.Context, in *DisableClusterConfigBackupRequest, opts ...grpc.CallOption) (*ClusterConfigBackupPolicy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClusterConfigBackupPolicy)
	err := c.cc.Invoke(ctx, ClusterService_DisableClusterConfigBackup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterServiceClient) ListClusterConfigBackup(ctx context.Context, in *ListClusterConfigBackupRequest, opts ...grpc.CallOption) (*ListClusterConfigBackupResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListClusterConfigBackupResponse)
	err := c.cc.Invoke(ctx, ClusterService_ListClusterConfigBackup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ClusterServiceServer is the server API for ClusterService service.
// All implementations should embed UnimplementedClusterServiceServer
// for forward compatibility
type ClusterServiceServer interface {
	CreateCluster(context.Context, *CreateClusterRequest) (*Cluster, error)
	ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error)
	GetCluster(context.Context, *GetClusterRequest) (*Cluster, error)
	// DeleteCluster deletes the cluster but keeps the backup records. The cluster can be restored from the backup.
	DeleteCluster(context.Context, *DeleteClusterRequest) (*Cluster, error)
	ScaleCluster(context.Context, *ScaleClusterRequest) (*Cluster, error)
	ScaleClusterWithMultiComponent(context.Context, *ScaleClusterWithMultiComponentRequest) (*Cluster, error)
	PauseCluster(context.Context, *PauseClusterRequest) (*Cluster, error)
	ResumeCluster(context.Context, *ResumeClusterRequest) (*Cluster, error)
	GetComponentNodeInfo(context.Context, *GetComponentNodeInfoRequest) (*GetComponentNodeInfoResponse, error)
	SetClientCaCertificate(context.Context, *SetClientCaCertificateRequest) (*emptypb.Empty, error)
	GetClientCaCertificate(context.Context, *GetClientCaCertificateRequest) (*GetClientCaCertificateResponse, error)
	ApplyCluster(context.Context, *ApplyClusterRequest) (*Cluster, error)
	ApplyGKEHeterogeneousDeploy(context.Context, *ApplyGKEHeterogeneousDeployRequest) (*GKEHeterogeneousDeploy, error)
	GetGKEHeterogeneousDeploy(context.Context, *GetGKEHeterogeneousDeployRequest) (*GKEHeterogeneousDeploy, error)
	DeleteGKEHeterogeneousDeploy(context.Context, *DeleteGKEHeterogeneousDeployRequest) (*emptypb.Empty, error)
	GetBillableClustersCount(context.Context, *GetBillableClustersCountRequest) (*GetBillableClustersCountResponse, error)
	GetClusterConfidentialInfo(context.Context, *GetClusterConfidentialInfoRequest) (*GetClusterConfidentialInfoResponse, error)
	CreateClusterSnapshot(context.Context, *CreateClusterSnapshotRequest) (*CreateClusterSnapshotResponse, error)
	ListClusterSnapshots(context.Context, *ListClusterSnapshotsRequest) (*ListClusterSnapshotsResponse, error)
	ListTenantQuota(context.Context, *ListTenantQuotaRequest) (*ListTenantQuotaResponse, error)
	UpdateTenantQuota(context.Context, *UpdateTenantQuotaRequest) (*UpdateTenantQuotaResponse, error)
	ChangeClusterPasswd(context.Context, *ChangeClusterPasswdRequest) (*ChangeClusterPasswdResponse, error)
	GetDefaultTidbVersion(context.Context, *GetDefaultTidbVersionRequest) (*GetDefaultTidbVersionResponse, error)
	GetLogRedactionPolicy(context.Context, *GetLogRedactionPolicyRequest) (*LogRedactionPolicy, error)
	UpdateLogRedactionPolicy(context.Context, *UpdateLogRedactionPolicyRequest) (*LogRedactionPolicy, error)
	// BuildDesiredComponents builds the desired components for a cluster based on the provided parameters.
	// It returns the current and desired components, and also the default components derived from SKUs.
	// One can use this RPC to diff component changes.
	BuildDesiredComponents(context.Context, *BuildDesiredComponentsRequest) (*BuildDesiredComponentsResponse, error)
	GetClusterCustomParams(context.Context, *GetClusterCustomParamsRequest) (*GetClusterCustomParamsResponse, error)
	SyncSystemVariables(context.Context, *SyncSystemVariablesRequest) (*emptypb.Empty, error)
	SyncPdOnlineConfig(context.Context, *SyncPdOnlineConfigRequest) (*emptypb.Empty, error)
	ShutdownUpgradeCluster(context.Context, *ShutdownUpgradeClusterRequest) (*emptypb.Empty, error)
	EnableClusterConfigBackup(context.Context, *EnableClusterConfigBackupRequest) (*ClusterConfigBackupPolicy, error)
	DisableClusterConfigBackup(context.Context, *DisableClusterConfigBackupRequest) (*ClusterConfigBackupPolicy, error)
	ListClusterConfigBackup(context.Context, *ListClusterConfigBackupRequest) (*ListClusterConfigBackupResponse, error)
}

// UnimplementedClusterServiceServer should be embedded to have forward compatible implementations.
type UnimplementedClusterServiceServer struct {
}

func (UnimplementedClusterServiceServer) CreateCluster(context.Context, *CreateClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCluster not implemented")
}
func (UnimplementedClusterServiceServer) ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClusters not implemented")
}
func (UnimplementedClusterServiceServer) GetCluster(context.Context, *GetClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCluster not implemented")
}
func (UnimplementedClusterServiceServer) DeleteCluster(context.Context, *DeleteClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCluster not implemented")
}
func (UnimplementedClusterServiceServer) ScaleCluster(context.Context, *ScaleClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ScaleCluster not implemented")
}
func (UnimplementedClusterServiceServer) ScaleClusterWithMultiComponent(context.Context, *ScaleClusterWithMultiComponentRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ScaleClusterWithMultiComponent not implemented")
}
func (UnimplementedClusterServiceServer) PauseCluster(context.Context, *PauseClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseCluster not implemented")
}
func (UnimplementedClusterServiceServer) ResumeCluster(context.Context, *ResumeClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResumeCluster not implemented")
}
func (UnimplementedClusterServiceServer) GetComponentNodeInfo(context.Context, *GetComponentNodeInfoRequest) (*GetComponentNodeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetComponentNodeInfo not implemented")
}
func (UnimplementedClusterServiceServer) SetClientCaCertificate(context.Context, *SetClientCaCertificateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetClientCaCertificate not implemented")
}
func (UnimplementedClusterServiceServer) GetClientCaCertificate(context.Context, *GetClientCaCertificateRequest) (*GetClientCaCertificateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClientCaCertificate not implemented")
}
func (UnimplementedClusterServiceServer) ApplyCluster(context.Context, *ApplyClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyCluster not implemented")
}
func (UnimplementedClusterServiceServer) ApplyGKEHeterogeneousDeploy(context.Context, *ApplyGKEHeterogeneousDeployRequest) (*GKEHeterogeneousDeploy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyGKEHeterogeneousDeploy not implemented")
}
func (UnimplementedClusterServiceServer) GetGKEHeterogeneousDeploy(context.Context, *GetGKEHeterogeneousDeployRequest) (*GKEHeterogeneousDeploy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGKEHeterogeneousDeploy not implemented")
}
func (UnimplementedClusterServiceServer) DeleteGKEHeterogeneousDeploy(context.Context, *DeleteGKEHeterogeneousDeployRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteGKEHeterogeneousDeploy not implemented")
}
func (UnimplementedClusterServiceServer) GetBillableClustersCount(context.Context, *GetBillableClustersCountRequest) (*GetBillableClustersCountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBillableClustersCount not implemented")
}
func (UnimplementedClusterServiceServer) GetClusterConfidentialInfo(context.Context, *GetClusterConfidentialInfoRequest) (*GetClusterConfidentialInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterConfidentialInfo not implemented")
}
func (UnimplementedClusterServiceServer) CreateClusterSnapshot(context.Context, *CreateClusterSnapshotRequest) (*CreateClusterSnapshotResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateClusterSnapshot not implemented")
}
func (UnimplementedClusterServiceServer) ListClusterSnapshots(context.Context, *ListClusterSnapshotsRequest) (*ListClusterSnapshotsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClusterSnapshots not implemented")
}
func (UnimplementedClusterServiceServer) ListTenantQuota(context.Context, *ListTenantQuotaRequest) (*ListTenantQuotaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTenantQuota not implemented")
}
func (UnimplementedClusterServiceServer) UpdateTenantQuota(context.Context, *UpdateTenantQuotaRequest) (*UpdateTenantQuotaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTenantQuota not implemented")
}
func (UnimplementedClusterServiceServer) ChangeClusterPasswd(context.Context, *ChangeClusterPasswdRequest) (*ChangeClusterPasswdResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChangeClusterPasswd not implemented")
}
func (UnimplementedClusterServiceServer) GetDefaultTidbVersion(context.Context, *GetDefaultTidbVersionRequest) (*GetDefaultTidbVersionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDefaultTidbVersion not implemented")
}
func (UnimplementedClusterServiceServer) GetLogRedactionPolicy(context.Context, *GetLogRedactionPolicyRequest) (*LogRedactionPolicy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLogRedactionPolicy not implemented")
}
func (UnimplementedClusterServiceServer) UpdateLogRedactionPolicy(context.Context, *UpdateLogRedactionPolicyRequest) (*LogRedactionPolicy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateLogRedactionPolicy not implemented")
}
func (UnimplementedClusterServiceServer) BuildDesiredComponents(context.Context, *BuildDesiredComponentsRequest) (*BuildDesiredComponentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BuildDesiredComponents not implemented")
}
func (UnimplementedClusterServiceServer) GetClusterCustomParams(context.Context, *GetClusterCustomParamsRequest) (*GetClusterCustomParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterCustomParams not implemented")
}
func (UnimplementedClusterServiceServer) SyncSystemVariables(context.Context, *SyncSystemVariablesRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncSystemVariables not implemented")
}
func (UnimplementedClusterServiceServer) SyncPdOnlineConfig(context.Context, *SyncPdOnlineConfigRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncPdOnlineConfig not implemented")
}
func (UnimplementedClusterServiceServer) ShutdownUpgradeCluster(context.Context, *ShutdownUpgradeClusterRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShutdownUpgradeCluster not implemented")
}
func (UnimplementedClusterServiceServer) EnableClusterConfigBackup(context.Context, *EnableClusterConfigBackupRequest) (*ClusterConfigBackupPolicy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableClusterConfigBackup not implemented")
}
func (UnimplementedClusterServiceServer) DisableClusterConfigBackup(context.Context, *DisableClusterConfigBackupRequest) (*ClusterConfigBackupPolicy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableClusterConfigBackup not implemented")
}
func (UnimplementedClusterServiceServer) ListClusterConfigBackup(context.Context, *ListClusterConfigBackupRequest) (*ListClusterConfigBackupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClusterConfigBackup not implemented")
}

// UnsafeClusterServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ClusterServiceServer will
// result in compilation errors.
type UnsafeClusterServiceServer interface {
	mustEmbedUnimplementedClusterServiceServer()
}

func RegisterClusterServiceServer(s grpc.ServiceRegistrar, srv ClusterServiceServer) {
	s.RegisterService(&ClusterService_ServiceDesc, srv)
}

func _ClusterService_CreateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).CreateCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_CreateCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).CreateCluster(ctx, req.(*CreateClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ListClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListClustersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ListClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ListClusters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ListClusters(ctx, req.(*ListClustersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetCluster(ctx, req.(*GetClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_DeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).DeleteCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_DeleteCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).DeleteCluster(ctx, req.(*DeleteClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ScaleCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ScaleClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ScaleCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ScaleCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ScaleCluster(ctx, req.(*ScaleClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ScaleClusterWithMultiComponent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ScaleClusterWithMultiComponentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ScaleClusterWithMultiComponent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ScaleClusterWithMultiComponent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ScaleClusterWithMultiComponent(ctx, req.(*ScaleClusterWithMultiComponentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_PauseCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).PauseCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_PauseCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).PauseCluster(ctx, req.(*PauseClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ResumeCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResumeClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ResumeCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ResumeCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ResumeCluster(ctx, req.(*ResumeClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetComponentNodeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetComponentNodeInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetComponentNodeInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetComponentNodeInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetComponentNodeInfo(ctx, req.(*GetComponentNodeInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_SetClientCaCertificate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetClientCaCertificateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).SetClientCaCertificate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_SetClientCaCertificate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).SetClientCaCertificate(ctx, req.(*SetClientCaCertificateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetClientCaCertificate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClientCaCertificateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetClientCaCertificate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetClientCaCertificate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetClientCaCertificate(ctx, req.(*GetClientCaCertificateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ApplyCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ApplyCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ApplyCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ApplyCluster(ctx, req.(*ApplyClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ApplyGKEHeterogeneousDeploy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyGKEHeterogeneousDeployRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ApplyGKEHeterogeneousDeploy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ApplyGKEHeterogeneousDeploy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ApplyGKEHeterogeneousDeploy(ctx, req.(*ApplyGKEHeterogeneousDeployRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetGKEHeterogeneousDeploy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetGKEHeterogeneousDeployRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetGKEHeterogeneousDeploy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetGKEHeterogeneousDeploy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetGKEHeterogeneousDeploy(ctx, req.(*GetGKEHeterogeneousDeployRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_DeleteGKEHeterogeneousDeploy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteGKEHeterogeneousDeployRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).DeleteGKEHeterogeneousDeploy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_DeleteGKEHeterogeneousDeploy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).DeleteGKEHeterogeneousDeploy(ctx, req.(*DeleteGKEHeterogeneousDeployRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetBillableClustersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBillableClustersCountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetBillableClustersCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetBillableClustersCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetBillableClustersCount(ctx, req.(*GetBillableClustersCountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetClusterConfidentialInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterConfidentialInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetClusterConfidentialInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetClusterConfidentialInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetClusterConfidentialInfo(ctx, req.(*GetClusterConfidentialInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_CreateClusterSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateClusterSnapshotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).CreateClusterSnapshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_CreateClusterSnapshot_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).CreateClusterSnapshot(ctx, req.(*CreateClusterSnapshotRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ListClusterSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListClusterSnapshotsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ListClusterSnapshots(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ListClusterSnapshots_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ListClusterSnapshots(ctx, req.(*ListClusterSnapshotsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ListTenantQuota_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTenantQuotaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ListTenantQuota(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ListTenantQuota_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ListTenantQuota(ctx, req.(*ListTenantQuotaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_UpdateTenantQuota_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTenantQuotaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).UpdateTenantQuota(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_UpdateTenantQuota_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).UpdateTenantQuota(ctx, req.(*UpdateTenantQuotaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ChangeClusterPasswd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangeClusterPasswdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ChangeClusterPasswd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ChangeClusterPasswd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ChangeClusterPasswd(ctx, req.(*ChangeClusterPasswdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetDefaultTidbVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDefaultTidbVersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetDefaultTidbVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetDefaultTidbVersion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetDefaultTidbVersion(ctx, req.(*GetDefaultTidbVersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetLogRedactionPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLogRedactionPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetLogRedactionPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetLogRedactionPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetLogRedactionPolicy(ctx, req.(*GetLogRedactionPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_UpdateLogRedactionPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateLogRedactionPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).UpdateLogRedactionPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_UpdateLogRedactionPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).UpdateLogRedactionPolicy(ctx, req.(*UpdateLogRedactionPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_BuildDesiredComponents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BuildDesiredComponentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).BuildDesiredComponents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_BuildDesiredComponents_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).BuildDesiredComponents(ctx, req.(*BuildDesiredComponentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_GetClusterCustomParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterCustomParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).GetClusterCustomParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_GetClusterCustomParams_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).GetClusterCustomParams(ctx, req.(*GetClusterCustomParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_SyncSystemVariables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncSystemVariablesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).SyncSystemVariables(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_SyncSystemVariables_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).SyncSystemVariables(ctx, req.(*SyncSystemVariablesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_SyncPdOnlineConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncPdOnlineConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).SyncPdOnlineConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_SyncPdOnlineConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).SyncPdOnlineConfig(ctx, req.(*SyncPdOnlineConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ShutdownUpgradeCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShutdownUpgradeClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ShutdownUpgradeCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ShutdownUpgradeCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ShutdownUpgradeCluster(ctx, req.(*ShutdownUpgradeClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_EnableClusterConfigBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableClusterConfigBackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).EnableClusterConfigBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_EnableClusterConfigBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).EnableClusterConfigBackup(ctx, req.(*EnableClusterConfigBackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_DisableClusterConfigBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableClusterConfigBackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).DisableClusterConfigBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_DisableClusterConfigBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).DisableClusterConfigBackup(ctx, req.(*DisableClusterConfigBackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterService_ListClusterConfigBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListClusterConfigBackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ListClusterConfigBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ListClusterConfigBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ListClusterConfigBackup(ctx, req.(*ListClusterConfigBackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ClusterService_ServiceDesc is the grpc.ServiceDesc for ClusterService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ClusterService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.ClusterService",
	HandlerType: (*ClusterServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateCluster",
			Handler:    _ClusterService_CreateCluster_Handler,
		},
		{
			MethodName: "ListClusters",
			Handler:    _ClusterService_ListClusters_Handler,
		},
		{
			MethodName: "GetCluster",
			Handler:    _ClusterService_GetCluster_Handler,
		},
		{
			MethodName: "DeleteCluster",
			Handler:    _ClusterService_DeleteCluster_Handler,
		},
		{
			MethodName: "ScaleCluster",
			Handler:    _ClusterService_ScaleCluster_Handler,
		},
		{
			MethodName: "ScaleClusterWithMultiComponent",
			Handler:    _ClusterService_ScaleClusterWithMultiComponent_Handler,
		},
		{
			MethodName: "PauseCluster",
			Handler:    _ClusterService_PauseCluster_Handler,
		},
		{
			MethodName: "ResumeCluster",
			Handler:    _ClusterService_ResumeCluster_Handler,
		},
		{
			MethodName: "GetComponentNodeInfo",
			Handler:    _ClusterService_GetComponentNodeInfo_Handler,
		},
		{
			MethodName: "SetClientCaCertificate",
			Handler:    _ClusterService_SetClientCaCertificate_Handler,
		},
		{
			MethodName: "GetClientCaCertificate",
			Handler:    _ClusterService_GetClientCaCertificate_Handler,
		},
		{
			MethodName: "ApplyCluster",
			Handler:    _ClusterService_ApplyCluster_Handler,
		},
		{
			MethodName: "ApplyGKEHeterogeneousDeploy",
			Handler:    _ClusterService_ApplyGKEHeterogeneousDeploy_Handler,
		},
		{
			MethodName: "GetGKEHeterogeneousDeploy",
			Handler:    _ClusterService_GetGKEHeterogeneousDeploy_Handler,
		},
		{
			MethodName: "DeleteGKEHeterogeneousDeploy",
			Handler:    _ClusterService_DeleteGKEHeterogeneousDeploy_Handler,
		},
		{
			MethodName: "GetBillableClustersCount",
			Handler:    _ClusterService_GetBillableClustersCount_Handler,
		},
		{
			MethodName: "GetClusterConfidentialInfo",
			Handler:    _ClusterService_GetClusterConfidentialInfo_Handler,
		},
		{
			MethodName: "CreateClusterSnapshot",
			Handler:    _ClusterService_CreateClusterSnapshot_Handler,
		},
		{
			MethodName: "ListClusterSnapshots",
			Handler:    _ClusterService_ListClusterSnapshots_Handler,
		},
		{
			MethodName: "ListTenantQuota",
			Handler:    _ClusterService_ListTenantQuota_Handler,
		},
		{
			MethodName: "UpdateTenantQuota",
			Handler:    _ClusterService_UpdateTenantQuota_Handler,
		},
		{
			MethodName: "ChangeClusterPasswd",
			Handler:    _ClusterService_ChangeClusterPasswd_Handler,
		},
		{
			MethodName: "GetDefaultTidbVersion",
			Handler:    _ClusterService_GetDefaultTidbVersion_Handler,
		},
		{
			MethodName: "GetLogRedactionPolicy",
			Handler:    _ClusterService_GetLogRedactionPolicy_Handler,
		},
		{
			MethodName: "UpdateLogRedactionPolicy",
			Handler:    _ClusterService_UpdateLogRedactionPolicy_Handler,
		},
		{
			MethodName: "BuildDesiredComponents",
			Handler:    _ClusterService_BuildDesiredComponents_Handler,
		},
		{
			MethodName: "GetClusterCustomParams",
			Handler:    _ClusterService_GetClusterCustomParams_Handler,
		},
		{
			MethodName: "SyncSystemVariables",
			Handler:    _ClusterService_SyncSystemVariables_Handler,
		},
		{
			MethodName: "SyncPdOnlineConfig",
			Handler:    _ClusterService_SyncPdOnlineConfig_Handler,
		},
		{
			MethodName: "ShutdownUpgradeCluster",
			Handler:    _ClusterService_ShutdownUpgradeCluster_Handler,
		},
		{
			MethodName: "EnableClusterConfigBackup",
			Handler:    _ClusterService_EnableClusterConfigBackup_Handler,
		},
		{
			MethodName: "DisableClusterConfigBackup",
			Handler:    _ClusterService_DisableClusterConfigBackup_Handler,
		},
		{
			MethodName: "ListClusterConfigBackup",
			Handler:    _ClusterService_ListClusterConfigBackup_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	RegionService_ListCloudProviders_FullMethodName     = "/global.dedicated.v1.RegionService/ListCloudProviders"
	RegionService_RegisterCloudProvider_FullMethodName  = "/global.dedicated.v1.RegionService/RegisterCloudProvider"
	RegionService_ListRegions_FullMethodName            = "/global.dedicated.v1.RegionService/ListRegions"
	RegionService_SelectRegionByOrgId_FullMethodName    = "/global.dedicated.v1.RegionService/SelectRegionByOrgId"
	RegionService_GetRegionByLogicalName_FullMethodName = "/global.dedicated.v1.RegionService/GetRegionByLogicalName"
	RegionService_RegisterRegion_FullMethodName         = "/global.dedicated.v1.RegionService/RegisterRegion"
	RegionService_UpdateRegion_FullMethodName           = "/global.dedicated.v1.RegionService/UpdateRegion"
	RegionService_CheckRegionStatus_FullMethodName      = "/global.dedicated.v1.RegionService/CheckRegionStatus"
	RegionService_DeleteRegion_FullMethodName           = "/global.dedicated.v1.RegionService/DeleteRegion"
)

// RegionServiceClient is the client API for RegionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RegionServiceClient interface {
	ListCloudProviders(ctx context.Context, in *ListCloudProvidersRequest, opts ...grpc.CallOption) (*ListCloudProvidersResponse, error)
	RegisterCloudProvider(ctx context.Context, in *RegisterCloudProviderRequest, opts ...grpc.CallOption) (*v1.CloudProvider, error)
	ListRegions(ctx context.Context, in *ListRegionsRequest, opts ...grpc.CallOption) (*ListRegionsResponse, error)
	SelectRegionByOrgId(ctx context.Context, in *SelectRegionByOrgIdRequest, opts ...grpc.CallOption) (*v1.Region, error)
	GetRegionByLogicalName(ctx context.Context, in *GetRegionByLogicalNameRequest, opts ...grpc.CallOption) (*v1.Region, error)
	RegisterRegion(ctx context.Context, in *RegisterRegionRequest, opts ...grpc.CallOption) (*v1.Region, error)
	UpdateRegion(ctx context.Context, in *UpdateRegionRequest, opts ...grpc.CallOption) (*v1.Region, error)
	CheckRegionStatus(ctx context.Context, in *CheckRegionStatusRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteRegion(ctx context.Context, in *DeleteRegionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type regionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRegionServiceClient(cc grpc.ClientConnInterface) RegionServiceClient {
	return &regionServiceClient{cc}
}

func (c *regionServiceClient) ListCloudProviders(ctx context.Context, in *ListCloudProvidersRequest, opts ...grpc.CallOption) (*ListCloudProvidersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListCloudProvidersResponse)
	err := c.cc.Invoke(ctx, RegionService_ListCloudProviders_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) RegisterCloudProvider(ctx context.Context, in *RegisterCloudProviderRequest, opts ...grpc.CallOption) (*v1.CloudProvider, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.CloudProvider)
	err := c.cc.Invoke(ctx, RegionService_RegisterCloudProvider_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) ListRegions(ctx context.Context, in *ListRegionsRequest, opts ...grpc.CallOption) (*ListRegionsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListRegionsResponse)
	err := c.cc.Invoke(ctx, RegionService_ListRegions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) SelectRegionByOrgId(ctx context.Context, in *SelectRegionByOrgIdRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_SelectRegionByOrgId_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) GetRegionByLogicalName(ctx context.Context, in *GetRegionByLogicalNameRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_GetRegionByLogicalName_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) RegisterRegion(ctx context.Context, in *RegisterRegionRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_RegisterRegion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) UpdateRegion(ctx context.Context, in *UpdateRegionRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_UpdateRegion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) CheckRegionStatus(ctx context.Context, in *CheckRegionStatusRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, RegionService_CheckRegionStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) DeleteRegion(ctx context.Context, in *DeleteRegionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, RegionService_DeleteRegion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RegionServiceServer is the server API for RegionService service.
// All implementations should embed UnimplementedRegionServiceServer
// for forward compatibility
type RegionServiceServer interface {
	ListCloudProviders(context.Context, *ListCloudProvidersRequest) (*ListCloudProvidersResponse, error)
	RegisterCloudProvider(context.Context, *RegisterCloudProviderRequest) (*v1.CloudProvider, error)
	ListRegions(context.Context, *ListRegionsRequest) (*ListRegionsResponse, error)
	SelectRegionByOrgId(context.Context, *SelectRegionByOrgIdRequest) (*v1.Region, error)
	GetRegionByLogicalName(context.Context, *GetRegionByLogicalNameRequest) (*v1.Region, error)
	RegisterRegion(context.Context, *RegisterRegionRequest) (*v1.Region, error)
	UpdateRegion(context.Context, *UpdateRegionRequest) (*v1.Region, error)
	CheckRegionStatus(context.Context, *CheckRegionStatusRequest) (*emptypb.Empty, error)
	DeleteRegion(context.Context, *DeleteRegionRequest) (*emptypb.Empty, error)
}

// UnimplementedRegionServiceServer should be embedded to have forward compatible implementations.
type UnimplementedRegionServiceServer struct {
}

func (UnimplementedRegionServiceServer) ListCloudProviders(context.Context, *ListCloudProvidersRequest) (*ListCloudProvidersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCloudProviders not implemented")
}
func (UnimplementedRegionServiceServer) RegisterCloudProvider(context.Context, *RegisterCloudProviderRequest) (*v1.CloudProvider, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterCloudProvider not implemented")
}
func (UnimplementedRegionServiceServer) ListRegions(context.Context, *ListRegionsRequest) (*ListRegionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRegions not implemented")
}
func (UnimplementedRegionServiceServer) SelectRegionByOrgId(context.Context, *SelectRegionByOrgIdRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SelectRegionByOrgId not implemented")
}
func (UnimplementedRegionServiceServer) GetRegionByLogicalName(context.Context, *GetRegionByLogicalNameRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRegionByLogicalName not implemented")
}
func (UnimplementedRegionServiceServer) RegisterRegion(context.Context, *RegisterRegionRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterRegion not implemented")
}
func (UnimplementedRegionServiceServer) UpdateRegion(context.Context, *UpdateRegionRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRegion not implemented")
}
func (UnimplementedRegionServiceServer) CheckRegionStatus(context.Context, *CheckRegionStatusRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckRegionStatus not implemented")
}
func (UnimplementedRegionServiceServer) DeleteRegion(context.Context, *DeleteRegionRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRegion not implemented")
}

// UnsafeRegionServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to RegionServiceServer will
// result in compilation errors.
type UnsafeRegionServiceServer interface {
	mustEmbedUnimplementedRegionServiceServer()
}

func RegisterRegionServiceServer(s grpc.ServiceRegistrar, srv RegionServiceServer) {
	s.RegisterService(&RegionService_ServiceDesc, srv)
}

func _RegionService_ListCloudProviders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCloudProvidersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).ListCloudProviders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_ListCloudProviders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).ListCloudProviders(ctx, req.(*ListCloudProvidersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_RegisterCloudProvider_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterCloudProviderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).RegisterCloudProvider(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_RegisterCloudProvider_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).RegisterCloudProvider(ctx, req.(*RegisterCloudProviderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_ListRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRegionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).ListRegions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_ListRegions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).ListRegions(ctx, req.(*ListRegionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_SelectRegionByOrgId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SelectRegionByOrgIdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).SelectRegionByOrgId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_SelectRegionByOrgId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).SelectRegionByOrgId(ctx, req.(*SelectRegionByOrgIdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_GetRegionByLogicalName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRegionByLogicalNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).GetRegionByLogicalName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_GetRegionByLogicalName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).GetRegionByLogicalName(ctx, req.(*GetRegionByLogicalNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_RegisterRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterRegionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).RegisterRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_RegisterRegion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).RegisterRegion(ctx, req.(*RegisterRegionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_UpdateRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRegionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).UpdateRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_UpdateRegion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).UpdateRegion(ctx, req.(*UpdateRegionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_CheckRegionStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckRegionStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).CheckRegionStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_CheckRegionStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).CheckRegionStatus(ctx, req.(*CheckRegionStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_DeleteRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteRegionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).DeleteRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_DeleteRegion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).DeleteRegion(ctx, req.(*DeleteRegionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RegionService_ServiceDesc is the grpc.ServiceDesc for RegionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RegionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.RegionService",
	HandlerType: (*RegionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListCloudProviders",
			Handler:    _RegionService_ListCloudProviders_Handler,
		},
		{
			MethodName: "RegisterCloudProvider",
			Handler:    _RegionService_RegisterCloudProvider_Handler,
		},
		{
			MethodName: "ListRegions",
			Handler:    _RegionService_ListRegions_Handler,
		},
		{
			MethodName: "SelectRegionByOrgId",
			Handler:    _RegionService_SelectRegionByOrgId_Handler,
		},
		{
			MethodName: "GetRegionByLogicalName",
			Handler:    _RegionService_GetRegionByLogicalName_Handler,
		},
		{
			MethodName: "RegisterRegion",
			Handler:    _RegionService_RegisterRegion_Handler,
		},
		{
			MethodName: "UpdateRegion",
			Handler:    _RegionService_UpdateRegion_Handler,
		},
		{
			MethodName: "CheckRegionStatus",
			Handler:    _RegionService_CheckRegionStatus_Handler,
		},
		{
			MethodName: "DeleteRegion",
			Handler:    _RegionService_DeleteRegion_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	SpuService_ListSpus_FullMethodName               = "/global.dedicated.v1.SpuService/ListSpus"
	SpuService_GetSpu_FullMethodName                 = "/global.dedicated.v1.SpuService/GetSpu"
	SpuService_BatchUpsertSpus_FullMethodName        = "/global.dedicated.v1.SpuService/BatchUpsertSpus"
	SpuService_GetInstanceMu_FullMethodName          = "/global.dedicated.v1.SpuService/GetInstanceMu"
	SpuService_GetStorageMu_FullMethodName           = "/global.dedicated.v1.SpuService/GetStorageMu"
	SpuService_ListInstanceMus_FullMethodName        = "/global.dedicated.v1.SpuService/ListInstanceMus"
	SpuService_ListStorageMus_FullMethodName         = "/global.dedicated.v1.SpuService/ListStorageMus"
	SpuService_BatchUpsertInstanceMus_FullMethodName = "/global.dedicated.v1.SpuService/BatchUpsertInstanceMus"
	SpuService_BatchUpsertStorageMus_FullMethodName  = "/global.dedicated.v1.SpuService/BatchUpsertStorageMus"
	SpuService_GetSku_FullMethodName                 = "/global.dedicated.v1.SpuService/GetSku"
	SpuService_ListSkus_FullMethodName               = "/global.dedicated.v1.SpuService/ListSkus"
	SpuService_BatchUpsertSkus_FullMethodName        = "/global.dedicated.v1.SpuService/BatchUpsertSkus"
)

// SpuServiceClient is the client API for SpuService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type SpuServiceClient interface {
	ListSpus(ctx context.Context, in *ListSpusRequest, opts ...grpc.CallOption) (*ListSpusResponse, error)
	GetSpu(ctx context.Context, in *GetSpuRequest, opts ...grpc.CallOption) (*Spu, error)
	BatchUpsertSpus(ctx context.Context, in *BatchUpsertSpusRequest, opts ...grpc.CallOption) (*BatchUpsertSpusResponse, error)
	GetInstanceMu(ctx context.Context, in *GetInstanceMuRequest, opts ...grpc.CallOption) (*InstanceMu, error)
	GetStorageMu(ctx context.Context, in *GetStorageMuRequest, opts ...grpc.CallOption) (*StorageMu, error)
	ListInstanceMus(ctx context.Context, in *ListInstanceMusRequest, opts ...grpc.CallOption) (*ListInstanceMusResponse, error)
	ListStorageMus(ctx context.Context, in *ListStorageMusRequest, opts ...grpc.CallOption) (*ListStorageMusResponse, error)
	BatchUpsertInstanceMus(ctx context.Context, in *BatchUpsertInstanceMusRequest, opts ...grpc.CallOption) (*BatchUpsertInstanceMusResponse, error)
	BatchUpsertStorageMus(ctx context.Context, in *BatchUpsertStorageMusRequest, opts ...grpc.CallOption) (*BatchUpsertStorageMusResponse, error)
	GetSku(ctx context.Context, in *GetSkuRequest, opts ...grpc.CallOption) (*Sku, error)
	ListSkus(ctx context.Context, in *ListSkusRequest, opts ...grpc.CallOption) (*ListSkusResponse, error)
	BatchUpsertSkus(ctx context.Context, in *BatchUpsertSkusRequest, opts ...grpc.CallOption) (*BatchUpsertSkusResponse, error)
}

type spuServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSpuServiceClient(cc grpc.ClientConnInterface) SpuServiceClient {
	return &spuServiceClient{cc}
}

func (c *spuServiceClient) ListSpus(ctx context.Context, in *ListSpusRequest, opts ...grpc.CallOption) (*ListSpusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSpusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListSpus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetSpu(ctx context.Context, in *GetSpuRequest, opts ...grpc.CallOption) (*Spu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Spu)
	err := c.cc.Invoke(ctx, SpuService_GetSpu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) BatchUpsertSpus(ctx context.Context, in *BatchUpsertSpusRequest, opts ...grpc.CallOption) (*BatchUpsertSpusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchUpsertSpusResponse)
	err := c.cc.Invoke(ctx, SpuService_BatchUpsertSpus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetInstanceMu(ctx context.Context, in *GetInstanceMuRequest, opts ...grpc.CallOption) (*InstanceMu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InstanceMu)
	err := c.cc.Invoke(ctx, SpuService_GetInstanceMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetStorageMu(ctx context.Context, in *GetStorageMuRequest, opts ...grpc.CallOption) (*StorageMu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StorageMu)
	err := c.cc.Invoke(ctx, SpuService_GetStorageMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListInstanceMus(ctx context.Context, in *ListInstanceMusRequest, opts ...grpc.CallOption) (*ListInstanceMusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListInstanceMusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListInstanceMus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListStorageMus(ctx context.Context, in *ListStorageMusRequest, opts ...grpc.CallOption) (*ListStorageMusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListStorageMusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListStorageMus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) BatchUpsertInstanceMus(ctx context.Context, in *BatchUpsertInstanceMusRequest, opts ...grpc.CallOption) (*BatchUpsertInstanceMusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchUpsertInstanceMusResponse)
	err := c.cc.Invoke(ctx, SpuService_BatchUpsertInstanceMus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) BatchUpsertStorageMus(ctx context.Context, in *BatchUpsertStorageMusRequest, opts ...grpc.CallOption) (*BatchUpsertStorageMusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchUpsertStorageMusResponse)
	err := c.cc.Invoke(ctx, SpuService_BatchUpsertStorageMus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetSku(ctx context.Context, in *GetSkuRequest, opts ...grpc.CallOption) (*Sku, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Sku)
	err := c.cc.Invoke(ctx, SpuService_GetSku_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListSkus(ctx context.Context, in *ListSkusRequest, opts ...grpc.CallOption) (*ListSkusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSkusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListSkus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) BatchUpsertSkus(ctx context.Context, in *BatchUpsertSkusRequest, opts ...grpc.CallOption) (*BatchUpsertSkusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchUpsertSkusResponse)
	err := c.cc.Invoke(ctx, SpuService_BatchUpsertSkus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SpuServiceServer is the server API for SpuService service.
// All implementations should embed UnimplementedSpuServiceServer
// for forward compatibility
type SpuServiceServer interface {
	ListSpus(context.Context, *ListSpusRequest) (*ListSpusResponse, error)
	GetSpu(context.Context, *GetSpuRequest) (*Spu, error)
	BatchUpsertSpus(context.Context, *BatchUpsertSpusRequest) (*BatchUpsertSpusResponse, error)
	GetInstanceMu(context.Context, *GetInstanceMuRequest) (*InstanceMu, error)
	GetStorageMu(context.Context, *GetStorageMuRequest) (*StorageMu, error)
	ListInstanceMus(context.Context, *ListInstanceMusRequest) (*ListInstanceMusResponse, error)
	ListStorageMus(context.Context, *ListStorageMusRequest) (*ListStorageMusResponse, error)
	BatchUpsertInstanceMus(context.Context, *BatchUpsertInstanceMusRequest) (*BatchUpsertInstanceMusResponse, error)
	BatchUpsertStorageMus(context.Context, *BatchUpsertStorageMusRequest) (*BatchUpsertStorageMusResponse, error)
	GetSku(context.Context, *GetSkuRequest) (*Sku, error)
	ListSkus(context.Context, *ListSkusRequest) (*ListSkusResponse, error)
	BatchUpsertSkus(context.Context, *BatchUpsertSkusRequest) (*BatchUpsertSkusResponse, error)
}

// UnimplementedSpuServiceServer should be embedded to have forward compatible implementations.
type UnimplementedSpuServiceServer struct {
}

func (UnimplementedSpuServiceServer) ListSpus(context.Context, *ListSpusRequest) (*ListSpusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSpus not implemented")
}
func (UnimplementedSpuServiceServer) GetSpu(context.Context, *GetSpuRequest) (*Spu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSpu not implemented")
}
func (UnimplementedSpuServiceServer) BatchUpsertSpus(context.Context, *BatchUpsertSpusRequest) (*BatchUpsertSpusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchUpsertSpus not implemented")
}
func (UnimplementedSpuServiceServer) GetInstanceMu(context.Context, *GetInstanceMuRequest) (*InstanceMu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInstanceMu not implemented")
}
func (UnimplementedSpuServiceServer) GetStorageMu(context.Context, *GetStorageMuRequest) (*StorageMu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStorageMu not implemented")
}
func (UnimplementedSpuServiceServer) ListInstanceMus(context.Context, *ListInstanceMusRequest) (*ListInstanceMusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListInstanceMus not implemented")
}
func (UnimplementedSpuServiceServer) ListStorageMus(context.Context, *ListStorageMusRequest) (*ListStorageMusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStorageMus not implemented")
}
func (UnimplementedSpuServiceServer) BatchUpsertInstanceMus(context.Context, *BatchUpsertInstanceMusRequest) (*BatchUpsertInstanceMusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchUpsertInstanceMus not implemented")
}
func (UnimplementedSpuServiceServer) BatchUpsertStorageMus(context.Context, *BatchUpsertStorageMusRequest) (*BatchUpsertStorageMusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchUpsertStorageMus not implemented")
}
func (UnimplementedSpuServiceServer) GetSku(context.Context, *GetSkuRequest) (*Sku, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSku not implemented")
}
func (UnimplementedSpuServiceServer) ListSkus(context.Context, *ListSkusRequest) (*ListSkusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSkus not implemented")
}
func (UnimplementedSpuServiceServer) BatchUpsertSkus(context.Context, *BatchUpsertSkusRequest) (*BatchUpsertSkusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchUpsertSkus not implemented")
}

// UnsafeSpuServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SpuServiceServer will
// result in compilation errors.
type UnsafeSpuServiceServer interface {
	mustEmbedUnimplementedSpuServiceServer()
}

func RegisterSpuServiceServer(s grpc.ServiceRegistrar, srv SpuServiceServer) {
	s.RegisterService(&SpuService_ServiceDesc, srv)
}

func _SpuService_ListSpus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSpusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListSpus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListSpus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListSpus(ctx, req.(*ListSpusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetSpu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSpuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetSpu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetSpu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetSpu(ctx, req.(*GetSpuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_BatchUpsertSpus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchUpsertSpusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).BatchUpsertSpus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_BatchUpsertSpus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).BatchUpsertSpus(ctx, req.(*BatchUpsertSpusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetInstanceMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInstanceMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetInstanceMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetInstanceMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetInstanceMu(ctx, req.(*GetInstanceMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetStorageMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStorageMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetStorageMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetStorageMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetStorageMu(ctx, req.(*GetStorageMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListInstanceMus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListInstanceMusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListInstanceMus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListInstanceMus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListInstanceMus(ctx, req.(*ListInstanceMusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListStorageMus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStorageMusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListStorageMus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListStorageMus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListStorageMus(ctx, req.(*ListStorageMusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_BatchUpsertInstanceMus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchUpsertInstanceMusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).BatchUpsertInstanceMus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_BatchUpsertInstanceMus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).BatchUpsertInstanceMus(ctx, req.(*BatchUpsertInstanceMusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_BatchUpsertStorageMus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchUpsertStorageMusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).BatchUpsertStorageMus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_BatchUpsertStorageMus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).BatchUpsertStorageMus(ctx, req.(*BatchUpsertStorageMusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetSku_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSkuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetSku(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetSku_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetSku(ctx, req.(*GetSkuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListSkus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSkusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListSkus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListSkus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListSkus(ctx, req.(*ListSkusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_BatchUpsertSkus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchUpsertSkusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).BatchUpsertSkus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_BatchUpsertSkus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).BatchUpsertSkus(ctx, req.(*BatchUpsertSkusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SpuService_ServiceDesc is the grpc.ServiceDesc for SpuService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SpuService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.SpuService",
	HandlerType: (*SpuServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListSpus",
			Handler:    _SpuService_ListSpus_Handler,
		},
		{
			MethodName: "GetSpu",
			Handler:    _SpuService_GetSpu_Handler,
		},
		{
			MethodName: "BatchUpsertSpus",
			Handler:    _SpuService_BatchUpsertSpus_Handler,
		},
		{
			MethodName: "GetInstanceMu",
			Handler:    _SpuService_GetInstanceMu_Handler,
		},
		{
			MethodName: "GetStorageMu",
			Handler:    _SpuService_GetStorageMu_Handler,
		},
		{
			MethodName: "ListInstanceMus",
			Handler:    _SpuService_ListInstanceMus_Handler,
		},
		{
			MethodName: "ListStorageMus",
			Handler:    _SpuService_ListStorageMus_Handler,
		},
		{
			MethodName: "BatchUpsertInstanceMus",
			Handler:    _SpuService_BatchUpsertInstanceMus_Handler,
		},
		{
			MethodName: "BatchUpsertStorageMus",
			Handler:    _SpuService_BatchUpsertStorageMus_Handler,
		},
		{
			MethodName: "GetSku",
			Handler:    _SpuService_GetSku_Handler,
		},
		{
			MethodName: "ListSkus",
			Handler:    _SpuService_ListSkus_Handler,
		},
		{
			MethodName: "BatchUpsertSkus",
			Handler:    _SpuService_BatchUpsertSkus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	TidbNodeGroupService_CreateTidbNodeGroup_FullMethodName         = "/global.dedicated.v1.TidbNodeGroupService/CreateTidbNodeGroup"
	TidbNodeGroupService_UpdateTidbNodeGroup_FullMethodName         = "/global.dedicated.v1.TidbNodeGroupService/UpdateTidbNodeGroup"
	TidbNodeGroupService_DeleteTidbNodeGroup_FullMethodName         = "/global.dedicated.v1.TidbNodeGroupService/DeleteTidbNodeGroup"
	TidbNodeGroupService_ListTidbNodeGroups_FullMethodName          = "/global.dedicated.v1.TidbNodeGroupService/ListTidbNodeGroups"
	TidbNodeGroupService_DisableTidbGroupDNS_FullMethodName         = "/global.dedicated.v1.TidbNodeGroupService/DisableTidbGroupDNS"
	TidbNodeGroupService_EnableTidbGroupDNS_FullMethodName          = "/global.dedicated.v1.TidbNodeGroupService/EnableTidbGroupDNS"
	TidbNodeGroupService_GetPrivateLinkIPAddressType_FullMethodName = "/global.dedicated.v1.TidbNodeGroupService/GetPrivateLinkIPAddressType"
	TidbNodeGroupService_SetPrivateLinkIPAddressType_FullMethodName = "/global.dedicated.v1.TidbNodeGroupService/SetPrivateLinkIPAddressType"
)

// TidbNodeGroupServiceClient is the client API for TidbNodeGroupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type TidbNodeGroupServiceClient interface {
	CreateTidbNodeGroup(ctx context.Context, in *CreateTidbNodeGroupRequest, opts ...grpc.CallOption) (*TidbNodeGroup, error)
	UpdateTidbNodeGroup(ctx context.Context, in *UpdateTidbNodeGroupRequest, opts ...grpc.CallOption) (*TidbNodeGroup, error)
	DeleteTidbNodeGroup(ctx context.Context, in *DeleteTidbNodeGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListTidbNodeGroups(ctx context.Context, in *ListTidbNodeGroupsRequest, opts ...grpc.CallOption) (*ListTidbNodeGroupsResponse, error)
	DisableTidbGroupDNS(ctx context.Context, in *DisableTidbGroupDNSRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	EnableTidbGroupDNS(ctx context.Context, in *EnableTidbGroupDNSRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetPrivateLinkIPAddressType(ctx context.Context, in *GetPrivateLinkIPAddressTypeRequest, opts ...grpc.CallOption) (*TidbGroupPrivateLinkIPAddressTypeStatus, error)
	SetPrivateLinkIPAddressType(ctx context.Context, in *SetPrivateLinkIPAddressTypeRequest, opts ...grpc.CallOption) (*TidbGroupPrivateLinkIPAddressTypeStatus, error)
}

type tidbNodeGroupServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTidbNodeGroupServiceClient(cc grpc.ClientConnInterface) TidbNodeGroupServiceClient {
	return &tidbNodeGroupServiceClient{cc}
}

func (c *tidbNodeGroupServiceClient) CreateTidbNodeGroup(ctx context.Context, in *CreateTidbNodeGroupRequest, opts ...grpc.CallOption) (*TidbNodeGroup, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TidbNodeGroup)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_CreateTidbNodeGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) UpdateTidbNodeGroup(ctx context.Context, in *UpdateTidbNodeGroupRequest, opts ...grpc.CallOption) (*TidbNodeGroup, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TidbNodeGroup)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_UpdateTidbNodeGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) DeleteTidbNodeGroup(ctx context.Context, in *DeleteTidbNodeGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_DeleteTidbNodeGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) ListTidbNodeGroups(ctx context.Context, in *ListTidbNodeGroupsRequest, opts ...grpc.CallOption) (*ListTidbNodeGroupsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTidbNodeGroupsResponse)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_ListTidbNodeGroups_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) DisableTidbGroupDNS(ctx context.Context, in *DisableTidbGroupDNSRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_DisableTidbGroupDNS_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) EnableTidbGroupDNS(ctx context.Context, in *EnableTidbGroupDNSRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_EnableTidbGroupDNS_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) GetPrivateLinkIPAddressType(ctx context.Context, in *GetPrivateLinkIPAddressTypeRequest, opts ...grpc.CallOption) (*TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TidbGroupPrivateLinkIPAddressTypeStatus)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_GetPrivateLinkIPAddressType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tidbNodeGroupServiceClient) SetPrivateLinkIPAddressType(ctx context.Context, in *SetPrivateLinkIPAddressTypeRequest, opts ...grpc.CallOption) (*TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TidbGroupPrivateLinkIPAddressTypeStatus)
	err := c.cc.Invoke(ctx, TidbNodeGroupService_SetPrivateLinkIPAddressType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TidbNodeGroupServiceServer is the server API for TidbNodeGroupService service.
// All implementations should embed UnimplementedTidbNodeGroupServiceServer
// for forward compatibility
type TidbNodeGroupServiceServer interface {
	CreateTidbNodeGroup(context.Context, *CreateTidbNodeGroupRequest) (*TidbNodeGroup, error)
	UpdateTidbNodeGroup(context.Context, *UpdateTidbNodeGroupRequest) (*TidbNodeGroup, error)
	DeleteTidbNodeGroup(context.Context, *DeleteTidbNodeGroupRequest) (*emptypb.Empty, error)
	ListTidbNodeGroups(context.Context, *ListTidbNodeGroupsRequest) (*ListTidbNodeGroupsResponse, error)
	DisableTidbGroupDNS(context.Context, *DisableTidbGroupDNSRequest) (*emptypb.Empty, error)
	EnableTidbGroupDNS(context.Context, *EnableTidbGroupDNSRequest) (*emptypb.Empty, error)
	GetPrivateLinkIPAddressType(context.Context, *GetPrivateLinkIPAddressTypeRequest) (*TidbGroupPrivateLinkIPAddressTypeStatus, error)
	SetPrivateLinkIPAddressType(context.Context, *SetPrivateLinkIPAddressTypeRequest) (*TidbGroupPrivateLinkIPAddressTypeStatus, error)
}

// UnimplementedTidbNodeGroupServiceServer should be embedded to have forward compatible implementations.
type UnimplementedTidbNodeGroupServiceServer struct {
}

func (UnimplementedTidbNodeGroupServiceServer) CreateTidbNodeGroup(context.Context, *CreateTidbNodeGroupRequest) (*TidbNodeGroup, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTidbNodeGroup not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) UpdateTidbNodeGroup(context.Context, *UpdateTidbNodeGroupRequest) (*TidbNodeGroup, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTidbNodeGroup not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) DeleteTidbNodeGroup(context.Context, *DeleteTidbNodeGroupRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTidbNodeGroup not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) ListTidbNodeGroups(context.Context, *ListTidbNodeGroupsRequest) (*ListTidbNodeGroupsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTidbNodeGroups not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) DisableTidbGroupDNS(context.Context, *DisableTidbGroupDNSRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableTidbGroupDNS not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) EnableTidbGroupDNS(context.Context, *EnableTidbGroupDNSRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableTidbGroupDNS not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) GetPrivateLinkIPAddressType(context.Context, *GetPrivateLinkIPAddressTypeRequest) (*TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLinkIPAddressType not implemented")
}
func (UnimplementedTidbNodeGroupServiceServer) SetPrivateLinkIPAddressType(context.Context, *SetPrivateLinkIPAddressTypeRequest) (*TidbGroupPrivateLinkIPAddressTypeStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPrivateLinkIPAddressType not implemented")
}

// UnsafeTidbNodeGroupServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TidbNodeGroupServiceServer will
// result in compilation errors.
type UnsafeTidbNodeGroupServiceServer interface {
	mustEmbedUnimplementedTidbNodeGroupServiceServer()
}

func RegisterTidbNodeGroupServiceServer(s grpc.ServiceRegistrar, srv TidbNodeGroupServiceServer) {
	s.RegisterService(&TidbNodeGroupService_ServiceDesc, srv)
}

func _TidbNodeGroupService_CreateTidbNodeGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateTidbNodeGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).CreateTidbNodeGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_CreateTidbNodeGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).CreateTidbNodeGroup(ctx, req.(*CreateTidbNodeGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_UpdateTidbNodeGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTidbNodeGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).UpdateTidbNodeGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_UpdateTidbNodeGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).UpdateTidbNodeGroup(ctx, req.(*UpdateTidbNodeGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_DeleteTidbNodeGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteTidbNodeGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).DeleteTidbNodeGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_DeleteTidbNodeGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).DeleteTidbNodeGroup(ctx, req.(*DeleteTidbNodeGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_ListTidbNodeGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTidbNodeGroupsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).ListTidbNodeGroups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_ListTidbNodeGroups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).ListTidbNodeGroups(ctx, req.(*ListTidbNodeGroupsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_DisableTidbGroupDNS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableTidbGroupDNSRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).DisableTidbGroupDNS(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_DisableTidbGroupDNS_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).DisableTidbGroupDNS(ctx, req.(*DisableTidbGroupDNSRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_EnableTidbGroupDNS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableTidbGroupDNSRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).EnableTidbGroupDNS(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_EnableTidbGroupDNS_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).EnableTidbGroupDNS(ctx, req.(*EnableTidbGroupDNSRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_GetPrivateLinkIPAddressType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrivateLinkIPAddressTypeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).GetPrivateLinkIPAddressType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_GetPrivateLinkIPAddressType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).GetPrivateLinkIPAddressType(ctx, req.(*GetPrivateLinkIPAddressTypeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TidbNodeGroupService_SetPrivateLinkIPAddressType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetPrivateLinkIPAddressTypeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TidbNodeGroupServiceServer).SetPrivateLinkIPAddressType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TidbNodeGroupService_SetPrivateLinkIPAddressType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TidbNodeGroupServiceServer).SetPrivateLinkIPAddressType(ctx, req.(*SetPrivateLinkIPAddressTypeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TidbNodeGroupService_ServiceDesc is the grpc.ServiceDesc for TidbNodeGroupService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TidbNodeGroupService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.TidbNodeGroupService",
	HandlerType: (*TidbNodeGroupServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateTidbNodeGroup",
			Handler:    _TidbNodeGroupService_CreateTidbNodeGroup_Handler,
		},
		{
			MethodName: "UpdateTidbNodeGroup",
			Handler:    _TidbNodeGroupService_UpdateTidbNodeGroup_Handler,
		},
		{
			MethodName: "DeleteTidbNodeGroup",
			Handler:    _TidbNodeGroupService_DeleteTidbNodeGroup_Handler,
		},
		{
			MethodName: "ListTidbNodeGroups",
			Handler:    _TidbNodeGroupService_ListTidbNodeGroups_Handler,
		},
		{
			MethodName: "DisableTidbGroupDNS",
			Handler:    _TidbNodeGroupService_DisableTidbGroupDNS_Handler,
		},
		{
			MethodName: "EnableTidbGroupDNS",
			Handler:    _TidbNodeGroupService_EnableTidbGroupDNS_Handler,
		},
		{
			MethodName: "GetPrivateLinkIPAddressType",
			Handler:    _TidbNodeGroupService_GetPrivateLinkIPAddressType_Handler,
		},
		{
			MethodName: "SetPrivateLinkIPAddressType",
			Handler:    _TidbNodeGroupService_SetPrivateLinkIPAddressType_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	VpcService_ListVpcs_FullMethodName         = "/global.dedicated.v1.VpcService/ListVpcs"
	VpcService_DeleteVpc_FullMethodName        = "/global.dedicated.v1.VpcService/DeleteVpc"
	VpcService_DeleteVpcPeering_FullMethodName = "/global.dedicated.v1.VpcService/DeleteVpcPeering"
	VpcService_ListVpcPeerings_FullMethodName  = "/global.dedicated.v1.VpcService/ListVpcPeerings"
	VpcService_GetVpcPeering_FullMethodName    = "/global.dedicated.v1.VpcService/GetVpcPeering"
	VpcService_CreateVpcPeering_FullMethodName = "/global.dedicated.v1.VpcService/CreateVpcPeering"
	VpcService_CreateCidr_FullMethodName       = "/global.dedicated.v1.VpcService/CreateCidr"
	VpcService_QueryCidrs_FullMethodName       = "/global.dedicated.v1.VpcService/QueryCidrs"
	VpcService_UpdateCidr_FullMethodName       = "/global.dedicated.v1.VpcService/UpdateCidr"
	VpcService_DeleteCidr_FullMethodName       = "/global.dedicated.v1.VpcService/DeleteCidr"
	VpcService_GetDefaultCidr_FullMethodName   = "/global.dedicated.v1.VpcService/GetDefaultCidr"
	VpcService_AddSecondaryCidr_FullMethodName = "/global.dedicated.v1.VpcService/AddSecondaryCidr"
)

// VpcServiceClient is the client API for VpcService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type VpcServiceClient interface {
	ListVpcs(ctx context.Context, in *ListVpcsRequest, opts ...grpc.CallOption) (*ListVpcsResponse, error)
	DeleteVpc(ctx context.Context, in *DeleteVpcRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteVpcPeering(ctx context.Context, in *DeleteVpcPeeringRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListVpcPeerings(ctx context.Context, in *ListVpcPeeringsRequest, opts ...grpc.CallOption) (*ListVpcPeeringsResponse, error)
	GetVpcPeering(ctx context.Context, in *GetVpcPeeringRequest, opts ...grpc.CallOption) (*VpcPeering, error)
	CreateVpcPeering(ctx context.Context, in *CreateVpcPeeringRequest, opts ...grpc.CallOption) (*CreateVpcPeeringResponse, error)
	CreateCidr(ctx context.Context, in *CreateCidrRequest, opts ...grpc.CallOption) (*CreateCidrResponse, error)
	QueryCidrs(ctx context.Context, in *QueryCidrsRequest, opts ...grpc.CallOption) (*QueryCidrsResponse, error)
	UpdateCidr(ctx context.Context, in *UpdateCidrRequest, opts ...grpc.CallOption) (*UpdateCidrResponse, error)
	DeleteCidr(ctx context.Context, in *DeleteCidrRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetDefaultCidr(ctx context.Context, in *GetDefaultCidrRequest, opts ...grpc.CallOption) (*GetDefaultCidrResponse, error)
	AddSecondaryCidr(ctx context.Context, in *AddSecondaryCidrRequest, opts ...grpc.CallOption) (*Vpc, error)
}

type vpcServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewVpcServiceClient(cc grpc.ClientConnInterface) VpcServiceClient {
	return &vpcServiceClient{cc}
}

func (c *vpcServiceClient) ListVpcs(ctx context.Context, in *ListVpcsRequest, opts ...grpc.CallOption) (*ListVpcsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListVpcsResponse)
	err := c.cc.Invoke(ctx, VpcService_ListVpcs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) DeleteVpc(ctx context.Context, in *DeleteVpcRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, VpcService_DeleteVpc_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) DeleteVpcPeering(ctx context.Context, in *DeleteVpcPeeringRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, VpcService_DeleteVpcPeering_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) ListVpcPeerings(ctx context.Context, in *ListVpcPeeringsRequest, opts ...grpc.CallOption) (*ListVpcPeeringsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListVpcPeeringsResponse)
	err := c.cc.Invoke(ctx, VpcService_ListVpcPeerings_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) GetVpcPeering(ctx context.Context, in *GetVpcPeeringRequest, opts ...grpc.CallOption) (*VpcPeering, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(VpcPeering)
	err := c.cc.Invoke(ctx, VpcService_GetVpcPeering_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) CreateVpcPeering(ctx context.Context, in *CreateVpcPeeringRequest, opts ...grpc.CallOption) (*CreateVpcPeeringResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateVpcPeeringResponse)
	err := c.cc.Invoke(ctx, VpcService_CreateVpcPeering_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) CreateCidr(ctx context.Context, in *CreateCidrRequest, opts ...grpc.CallOption) (*CreateCidrResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateCidrResponse)
	err := c.cc.Invoke(ctx, VpcService_CreateCidr_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) QueryCidrs(ctx context.Context, in *QueryCidrsRequest, opts ...grpc.CallOption) (*QueryCidrsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(QueryCidrsResponse)
	err := c.cc.Invoke(ctx, VpcService_QueryCidrs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) UpdateCidr(ctx context.Context, in *UpdateCidrRequest, opts ...grpc.CallOption) (*UpdateCidrResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateCidrResponse)
	err := c.cc.Invoke(ctx, VpcService_UpdateCidr_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) DeleteCidr(ctx context.Context, in *DeleteCidrRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, VpcService_DeleteCidr_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) GetDefaultCidr(ctx context.Context, in *GetDefaultCidrRequest, opts ...grpc.CallOption) (*GetDefaultCidrResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetDefaultCidrResponse)
	err := c.cc.Invoke(ctx, VpcService_GetDefaultCidr_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcServiceClient) AddSecondaryCidr(ctx context.Context, in *AddSecondaryCidrRequest, opts ...grpc.CallOption) (*Vpc, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Vpc)
	err := c.cc.Invoke(ctx, VpcService_AddSecondaryCidr_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VpcServiceServer is the server API for VpcService service.
// All implementations should embed UnimplementedVpcServiceServer
// for forward compatibility
type VpcServiceServer interface {
	ListVpcs(context.Context, *ListVpcsRequest) (*ListVpcsResponse, error)
	DeleteVpc(context.Context, *DeleteVpcRequest) (*emptypb.Empty, error)
	DeleteVpcPeering(context.Context, *DeleteVpcPeeringRequest) (*emptypb.Empty, error)
	ListVpcPeerings(context.Context, *ListVpcPeeringsRequest) (*ListVpcPeeringsResponse, error)
	GetVpcPeering(context.Context, *GetVpcPeeringRequest) (*VpcPeering, error)
	CreateVpcPeering(context.Context, *CreateVpcPeeringRequest) (*CreateVpcPeeringResponse, error)
	CreateCidr(context.Context, *CreateCidrRequest) (*CreateCidrResponse, error)
	QueryCidrs(context.Context, *QueryCidrsRequest) (*QueryCidrsResponse, error)
	UpdateCidr(context.Context, *UpdateCidrRequest) (*UpdateCidrResponse, error)
	DeleteCidr(context.Context, *DeleteCidrRequest) (*emptypb.Empty, error)
	GetDefaultCidr(context.Context, *GetDefaultCidrRequest) (*GetDefaultCidrResponse, error)
	AddSecondaryCidr(context.Context, *AddSecondaryCidrRequest) (*Vpc, error)
}

// UnimplementedVpcServiceServer should be embedded to have forward compatible implementations.
type UnimplementedVpcServiceServer struct {
}

func (UnimplementedVpcServiceServer) ListVpcs(context.Context, *ListVpcsRequest) (*ListVpcsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListVpcs not implemented")
}
func (UnimplementedVpcServiceServer) DeleteVpc(context.Context, *DeleteVpcRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteVpc not implemented")
}
func (UnimplementedVpcServiceServer) DeleteVpcPeering(context.Context, *DeleteVpcPeeringRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteVpcPeering not implemented")
}
func (UnimplementedVpcServiceServer) ListVpcPeerings(context.Context, *ListVpcPeeringsRequest) (*ListVpcPeeringsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListVpcPeerings not implemented")
}
func (UnimplementedVpcServiceServer) GetVpcPeering(context.Context, *GetVpcPeeringRequest) (*VpcPeering, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVpcPeering not implemented")
}
func (UnimplementedVpcServiceServer) CreateVpcPeering(context.Context, *CreateVpcPeeringRequest) (*CreateVpcPeeringResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateVpcPeering not implemented")
}
func (UnimplementedVpcServiceServer) CreateCidr(context.Context, *CreateCidrRequest) (*CreateCidrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCidr not implemented")
}
func (UnimplementedVpcServiceServer) QueryCidrs(context.Context, *QueryCidrsRequest) (*QueryCidrsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryCidrs not implemented")
}
func (UnimplementedVpcServiceServer) UpdateCidr(context.Context, *UpdateCidrRequest) (*UpdateCidrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCidr not implemented")
}
func (UnimplementedVpcServiceServer) DeleteCidr(context.Context, *DeleteCidrRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCidr not implemented")
}
func (UnimplementedVpcServiceServer) GetDefaultCidr(context.Context, *GetDefaultCidrRequest) (*GetDefaultCidrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDefaultCidr not implemented")
}
func (UnimplementedVpcServiceServer) AddSecondaryCidr(context.Context, *AddSecondaryCidrRequest) (*Vpc, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddSecondaryCidr not implemented")
}

// UnsafeVpcServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to VpcServiceServer will
// result in compilation errors.
type UnsafeVpcServiceServer interface {
	mustEmbedUnimplementedVpcServiceServer()
}

func RegisterVpcServiceServer(s grpc.ServiceRegistrar, srv VpcServiceServer) {
	s.RegisterService(&VpcService_ServiceDesc, srv)
}

func _VpcService_ListVpcs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListVpcsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).ListVpcs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_ListVpcs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).ListVpcs(ctx, req.(*ListVpcsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_DeleteVpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteVpcRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).DeleteVpc(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_DeleteVpc_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).DeleteVpc(ctx, req.(*DeleteVpcRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_DeleteVpcPeering_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteVpcPeeringRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).DeleteVpcPeering(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_DeleteVpcPeering_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).DeleteVpcPeering(ctx, req.(*DeleteVpcPeeringRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_ListVpcPeerings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListVpcPeeringsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).ListVpcPeerings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_ListVpcPeerings_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).ListVpcPeerings(ctx, req.(*ListVpcPeeringsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_GetVpcPeering_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVpcPeeringRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).GetVpcPeering(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_GetVpcPeering_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).GetVpcPeering(ctx, req.(*GetVpcPeeringRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_CreateVpcPeering_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateVpcPeeringRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).CreateVpcPeering(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_CreateVpcPeering_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).CreateVpcPeering(ctx, req.(*CreateVpcPeeringRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_CreateCidr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateCidrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).CreateCidr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_CreateCidr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).CreateCidr(ctx, req.(*CreateCidrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_QueryCidrs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCidrsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).QueryCidrs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_QueryCidrs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).QueryCidrs(ctx, req.(*QueryCidrsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_UpdateCidr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateCidrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).UpdateCidr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_UpdateCidr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).UpdateCidr(ctx, req.(*UpdateCidrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_DeleteCidr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteCidrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).DeleteCidr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_DeleteCidr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).DeleteCidr(ctx, req.(*DeleteCidrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_GetDefaultCidr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDefaultCidrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).GetDefaultCidr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_GetDefaultCidr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).GetDefaultCidr(ctx, req.(*GetDefaultCidrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcService_AddSecondaryCidr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddSecondaryCidrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcServiceServer).AddSecondaryCidr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcService_AddSecondaryCidr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcServiceServer).AddSecondaryCidr(ctx, req.(*AddSecondaryCidrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// VpcService_ServiceDesc is the grpc.ServiceDesc for VpcService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var VpcService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.VpcService",
	HandlerType: (*VpcServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListVpcs",
			Handler:    _VpcService_ListVpcs_Handler,
		},
		{
			MethodName: "DeleteVpc",
			Handler:    _VpcService_DeleteVpc_Handler,
		},
		{
			MethodName: "DeleteVpcPeering",
			Handler:    _VpcService_DeleteVpcPeering_Handler,
		},
		{
			MethodName: "ListVpcPeerings",
			Handler:    _VpcService_ListVpcPeerings_Handler,
		},
		{
			MethodName: "GetVpcPeering",
			Handler:    _VpcService_GetVpcPeering_Handler,
		},
		{
			MethodName: "CreateVpcPeering",
			Handler:    _VpcService_CreateVpcPeering_Handler,
		},
		{
			MethodName: "CreateCidr",
			Handler:    _VpcService_CreateCidr_Handler,
		},
		{
			MethodName: "QueryCidrs",
			Handler:    _VpcService_QueryCidrs_Handler,
		},
		{
			MethodName: "UpdateCidr",
			Handler:    _VpcService_UpdateCidr_Handler,
		},
		{
			MethodName: "DeleteCidr",
			Handler:    _VpcService_DeleteCidr_Handler,
		},
		{
			MethodName: "GetDefaultCidr",
			Handler:    _VpcService_GetDefaultCidr_Handler,
		},
		{
			MethodName: "AddSecondaryCidr",
			Handler:    _VpcService_AddSecondaryCidr_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	PrivateLinkConnectionService_CreatePrivateLinkService_FullMethodName              = "/global.dedicated.v1.PrivateLinkConnectionService/CreatePrivateLinkService"
	PrivateLinkConnectionService_DeletePrivateLinkService_FullMethodName              = "/global.dedicated.v1.PrivateLinkConnectionService/DeletePrivateLinkService"
	PrivateLinkConnectionService_GetPrivateLinkService_FullMethodName                 = "/global.dedicated.v1.PrivateLinkConnectionService/GetPrivateLinkService"
	PrivateLinkConnectionService_CreatePrivateLinkEndpoint_FullMethodName             = "/global.dedicated.v1.PrivateLinkConnectionService/CreatePrivateLinkEndpoint"
	PrivateLinkConnectionService_DeletePrivateLinkEndpoint_FullMethodName             = "/global.dedicated.v1.PrivateLinkConnectionService/DeletePrivateLinkEndpoint"
	PrivateLinkConnectionService_ListPrivateLinkEndpoints_FullMethodName              = "/global.dedicated.v1.PrivateLinkConnectionService/ListPrivateLinkEndpoints"
	PrivateLinkConnectionService_ListTidbNodeGroupPrivateLinkEndpoints_FullMethodName = "/global.dedicated.v1.PrivateLinkConnectionService/ListTidbNodeGroupPrivateLinkEndpoints"
	PrivateLinkConnectionService_RejectVpcEndpointConnections_FullMethodName          = "/global.dedicated.v1.PrivateLinkConnectionService/RejectVpcEndpointConnections"
	PrivateLinkConnectionService_PausePrivateLinkService_FullMethodName               = "/global.dedicated.v1.PrivateLinkConnectionService/PausePrivateLinkService"
	PrivateLinkConnectionService_PurgePrivateLinkServiceMetadata_FullMethodName       = "/global.dedicated.v1.PrivateLinkConnectionService/PurgePrivateLinkServiceMetadata"
)

// PrivateLinkConnectionServiceClient is the client API for PrivateLinkConnectionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type PrivateLinkConnectionServiceClient interface {
	CreatePrivateLinkService(ctx context.Context, in *CreatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*CreatePrivateLinkServiceResponse, error)
	DeletePrivateLinkService(ctx context.Context, in *DeletePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Deprecated: Do not use.
	// Deprecated: This method only returns the private link service of the default Tidb node group.
	GetPrivateLinkService(ctx context.Context, in *GetPrivateLinkServiceRequest, opts ...grpc.CallOption) (*GetPrivateLinkServiceResponse, error)
	CreatePrivateLinkEndpoint(ctx context.Context, in *CreatePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*CreatePrivateLinkEndpointResponse, error)
	DeletePrivateLinkEndpoint(ctx context.Context, in *DeletePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// only list endpoints of default Tidb node group
	ListPrivateLinkEndpoints(ctx context.Context, in *ListPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*ListPrivateLinkEndpointsResponse, error)
	ListTidbNodeGroupPrivateLinkEndpoints(ctx context.Context, in *ListTidbNodeGroupPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*ListTidbNodeGroupPrivateLinkEndpointsResponse, error)
	RejectVpcEndpointConnections(ctx context.Context, in *RejectVpcEndpointConnectionsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PausePrivateLinkService(ctx context.Context, in *PausePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PurgePrivateLinkServiceMetadata(ctx context.Context, in *PurgePrivateLinkServiceMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type privateLinkConnectionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewPrivateLinkConnectionServiceClient(cc grpc.ClientConnInterface) PrivateLinkConnectionServiceClient {
	return &privateLinkConnectionServiceClient{cc}
}

func (c *privateLinkConnectionServiceClient) CreatePrivateLinkService(ctx context.Context, in *CreatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*CreatePrivateLinkServiceResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreatePrivateLinkServiceResponse)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_CreatePrivateLinkService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) DeletePrivateLinkService(ctx context.Context, in *DeletePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_DeletePrivateLinkService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *privateLinkConnectionServiceClient) GetPrivateLinkService(ctx context.Context, in *GetPrivateLinkServiceRequest, opts ...grpc.CallOption) (*GetPrivateLinkServiceResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetPrivateLinkServiceResponse)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_GetPrivateLinkService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) CreatePrivateLinkEndpoint(ctx context.Context, in *CreatePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*CreatePrivateLinkEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreatePrivateLinkEndpointResponse)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_CreatePrivateLinkEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) DeletePrivateLinkEndpoint(ctx context.Context, in *DeletePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_DeletePrivateLinkEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) ListPrivateLinkEndpoints(ctx context.Context, in *ListPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*ListPrivateLinkEndpointsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPrivateLinkEndpointsResponse)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_ListPrivateLinkEndpoints_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) ListTidbNodeGroupPrivateLinkEndpoints(ctx context.Context, in *ListTidbNodeGroupPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*ListTidbNodeGroupPrivateLinkEndpointsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTidbNodeGroupPrivateLinkEndpointsResponse)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_ListTidbNodeGroupPrivateLinkEndpoints_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) RejectVpcEndpointConnections(ctx context.Context, in *RejectVpcEndpointConnectionsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_RejectVpcEndpointConnections_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) PausePrivateLinkService(ctx context.Context, in *PausePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_PausePrivateLinkService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privateLinkConnectionServiceClient) PurgePrivateLinkServiceMetadata(ctx context.Context, in *PurgePrivateLinkServiceMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, PrivateLinkConnectionService_PurgePrivateLinkServiceMetadata_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PrivateLinkConnectionServiceServer is the server API for PrivateLinkConnectionService service.
// All implementations should embed UnimplementedPrivateLinkConnectionServiceServer
// for forward compatibility
type PrivateLinkConnectionServiceServer interface {
	CreatePrivateLinkService(context.Context, *CreatePrivateLinkServiceRequest) (*CreatePrivateLinkServiceResponse, error)
	DeletePrivateLinkService(context.Context, *DeletePrivateLinkServiceRequest) (*emptypb.Empty, error)
	// Deprecated: Do not use.
	// Deprecated: This method only returns the private link service of the default Tidb node group.
	GetPrivateLinkService(context.Context, *GetPrivateLinkServiceRequest) (*GetPrivateLinkServiceResponse, error)
	CreatePrivateLinkEndpoint(context.Context, *CreatePrivateLinkEndpointRequest) (*CreatePrivateLinkEndpointResponse, error)
	DeletePrivateLinkEndpoint(context.Context, *DeletePrivateLinkEndpointRequest) (*emptypb.Empty, error)
	// only list endpoints of default Tidb node group
	ListPrivateLinkEndpoints(context.Context, *ListPrivateLinkEndpointsRequest) (*ListPrivateLinkEndpointsResponse, error)
	ListTidbNodeGroupPrivateLinkEndpoints(context.Context, *ListTidbNodeGroupPrivateLinkEndpointsRequest) (*ListTidbNodeGroupPrivateLinkEndpointsResponse, error)
	RejectVpcEndpointConnections(context.Context, *RejectVpcEndpointConnectionsRequest) (*emptypb.Empty, error)
	PausePrivateLinkService(context.Context, *PausePrivateLinkServiceRequest) (*emptypb.Empty, error)
	PurgePrivateLinkServiceMetadata(context.Context, *PurgePrivateLinkServiceMetadataRequest) (*emptypb.Empty, error)
}

// UnimplementedPrivateLinkConnectionServiceServer should be embedded to have forward compatible implementations.
type UnimplementedPrivateLinkConnectionServiceServer struct {
}

func (UnimplementedPrivateLinkConnectionServiceServer) CreatePrivateLinkService(context.Context, *CreatePrivateLinkServiceRequest) (*CreatePrivateLinkServiceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateLinkService not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) DeletePrivateLinkService(context.Context, *DeletePrivateLinkServiceRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePrivateLinkService not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) GetPrivateLinkService(context.Context, *GetPrivateLinkServiceRequest) (*GetPrivateLinkServiceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLinkService not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) CreatePrivateLinkEndpoint(context.Context, *CreatePrivateLinkEndpointRequest) (*CreatePrivateLinkEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateLinkEndpoint not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) DeletePrivateLinkEndpoint(context.Context, *DeletePrivateLinkEndpointRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePrivateLinkEndpoint not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) ListPrivateLinkEndpoints(context.Context, *ListPrivateLinkEndpointsRequest) (*ListPrivateLinkEndpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPrivateLinkEndpoints not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) ListTidbNodeGroupPrivateLinkEndpoints(context.Context, *ListTidbNodeGroupPrivateLinkEndpointsRequest) (*ListTidbNodeGroupPrivateLinkEndpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTidbNodeGroupPrivateLinkEndpoints not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) RejectVpcEndpointConnections(context.Context, *RejectVpcEndpointConnectionsRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RejectVpcEndpointConnections not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) PausePrivateLinkService(context.Context, *PausePrivateLinkServiceRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PausePrivateLinkService not implemented")
}
func (UnimplementedPrivateLinkConnectionServiceServer) PurgePrivateLinkServiceMetadata(context.Context, *PurgePrivateLinkServiceMetadataRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PurgePrivateLinkServiceMetadata not implemented")
}

// UnsafePrivateLinkConnectionServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to PrivateLinkConnectionServiceServer will
// result in compilation errors.
type UnsafePrivateLinkConnectionServiceServer interface {
	mustEmbedUnimplementedPrivateLinkConnectionServiceServer()
}

func RegisterPrivateLinkConnectionServiceServer(s grpc.ServiceRegistrar, srv PrivateLinkConnectionServiceServer) {
	s.RegisterService(&PrivateLinkConnectionService_ServiceDesc, srv)
}

func _PrivateLinkConnectionService_CreatePrivateLinkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePrivateLinkServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).CreatePrivateLinkService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_CreatePrivateLinkService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).CreatePrivateLinkService(ctx, req.(*CreatePrivateLinkServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_DeletePrivateLinkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePrivateLinkServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).DeletePrivateLinkService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_DeletePrivateLinkService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).DeletePrivateLinkService(ctx, req.(*DeletePrivateLinkServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_GetPrivateLinkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrivateLinkServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).GetPrivateLinkService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_GetPrivateLinkService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).GetPrivateLinkService(ctx, req.(*GetPrivateLinkServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_CreatePrivateLinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePrivateLinkEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).CreatePrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_CreatePrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).CreatePrivateLinkEndpoint(ctx, req.(*CreatePrivateLinkEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_DeletePrivateLinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePrivateLinkEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).DeletePrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_DeletePrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).DeletePrivateLinkEndpoint(ctx, req.(*DeletePrivateLinkEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_ListPrivateLinkEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPrivateLinkEndpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).ListPrivateLinkEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_ListPrivateLinkEndpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).ListPrivateLinkEndpoints(ctx, req.(*ListPrivateLinkEndpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_ListTidbNodeGroupPrivateLinkEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTidbNodeGroupPrivateLinkEndpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).ListTidbNodeGroupPrivateLinkEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_ListTidbNodeGroupPrivateLinkEndpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).ListTidbNodeGroupPrivateLinkEndpoints(ctx, req.(*ListTidbNodeGroupPrivateLinkEndpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_RejectVpcEndpointConnections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RejectVpcEndpointConnectionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).RejectVpcEndpointConnections(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_RejectVpcEndpointConnections_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).RejectVpcEndpointConnections(ctx, req.(*RejectVpcEndpointConnectionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_PausePrivateLinkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PausePrivateLinkServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).PausePrivateLinkService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_PausePrivateLinkService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).PausePrivateLinkService(ctx, req.(*PausePrivateLinkServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PrivateLinkConnectionService_PurgePrivateLinkServiceMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PurgePrivateLinkServiceMetadataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivateLinkConnectionServiceServer).PurgePrivateLinkServiceMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PrivateLinkConnectionService_PurgePrivateLinkServiceMetadata_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivateLinkConnectionServiceServer).PurgePrivateLinkServiceMetadata(ctx, req.(*PurgePrivateLinkServiceMetadataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// PrivateLinkConnectionService_ServiceDesc is the grpc.ServiceDesc for PrivateLinkConnectionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PrivateLinkConnectionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.PrivateLinkConnectionService",
	HandlerType: (*PrivateLinkConnectionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreatePrivateLinkService",
			Handler:    _PrivateLinkConnectionService_CreatePrivateLinkService_Handler,
		},
		{
			MethodName: "DeletePrivateLinkService",
			Handler:    _PrivateLinkConnectionService_DeletePrivateLinkService_Handler,
		},
		{
			MethodName: "GetPrivateLinkService",
			Handler:    _PrivateLinkConnectionService_GetPrivateLinkService_Handler,
		},
		{
			MethodName: "CreatePrivateLinkEndpoint",
			Handler:    _PrivateLinkConnectionService_CreatePrivateLinkEndpoint_Handler,
		},
		{
			MethodName: "DeletePrivateLinkEndpoint",
			Handler:    _PrivateLinkConnectionService_DeletePrivateLinkEndpoint_Handler,
		},
		{
			MethodName: "ListPrivateLinkEndpoints",
			Handler:    _PrivateLinkConnectionService_ListPrivateLinkEndpoints_Handler,
		},
		{
			MethodName: "ListTidbNodeGroupPrivateLinkEndpoints",
			Handler:    _PrivateLinkConnectionService_ListTidbNodeGroupPrivateLinkEndpoints_Handler,
		},
		{
			MethodName: "RejectVpcEndpointConnections",
			Handler:    _PrivateLinkConnectionService_RejectVpcEndpointConnections_Handler,
		},
		{
			MethodName: "PausePrivateLinkService",
			Handler:    _PrivateLinkConnectionService_PausePrivateLinkService_Handler,
		},
		{
			MethodName: "PurgePrivateLinkServiceMetadata",
			Handler:    _PrivateLinkConnectionService_PurgePrivateLinkServiceMetadata_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	CustomerManagedEncryptionService_CreateCustomerManagedEncryptionKey_FullMethodName = "/global.dedicated.v1.CustomerManagedEncryptionService/CreateCustomerManagedEncryptionKey"
	CustomerManagedEncryptionService_GetCustomerManagedEncryptionKey_FullMethodName    = "/global.dedicated.v1.CustomerManagedEncryptionService/GetCustomerManagedEncryptionKey"
	CustomerManagedEncryptionService_ListCustomerManagedEncryptionKeys_FullMethodName  = "/global.dedicated.v1.CustomerManagedEncryptionService/ListCustomerManagedEncryptionKeys"
	CustomerManagedEncryptionService_DeleteCustomerManagedEncryptionKey_FullMethodName = "/global.dedicated.v1.CustomerManagedEncryptionService/DeleteCustomerManagedEncryptionKey"
	CustomerManagedEncryptionService_GetCmekAccessIamPrincipal_FullMethodName          = "/global.dedicated.v1.CustomerManagedEncryptionService/GetCmekAccessIamPrincipal"
)

// CustomerManagedEncryptionServiceClient is the client API for CustomerManagedEncryptionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CustomerManagedEncryptionServiceClient interface {
	CreateCustomerManagedEncryptionKey(ctx context.Context, in *CreateCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*CustomerManagedEncryptionKey, error)
	GetCustomerManagedEncryptionKey(ctx context.Context, in *GetCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*CustomerManagedEncryptionKey, error)
	ListCustomerManagedEncryptionKeys(ctx context.Context, in *ListCustomerManagedEncryptionKeysRequest, opts ...grpc.CallOption) (*ListCustomerManagedEncryptionKeysResponse, error)
	DeleteCustomerManagedEncryptionKey(ctx context.Context, in *DeleteCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetCmekAccessIamPrincipal(ctx context.Context, in *GetCmekAccessIamPrincipalRequest, opts ...grpc.CallOption) (*GetCmekAccessIamPrincipalResponse, error)
}

type customerManagedEncryptionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCustomerManagedEncryptionServiceClient(cc grpc.ClientConnInterface) CustomerManagedEncryptionServiceClient {
	return &customerManagedEncryptionServiceClient{cc}
}

func (c *customerManagedEncryptionServiceClient) CreateCustomerManagedEncryptionKey(ctx context.Context, in *CreateCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*CustomerManagedEncryptionKey, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CustomerManagedEncryptionKey)
	err := c.cc.Invoke(ctx, CustomerManagedEncryptionService_CreateCustomerManagedEncryptionKey_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *customerManagedEncryptionServiceClient) GetCustomerManagedEncryptionKey(ctx context.Context, in *GetCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*CustomerManagedEncryptionKey, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CustomerManagedEncryptionKey)
	err := c.cc.Invoke(ctx, CustomerManagedEncryptionService_GetCustomerManagedEncryptionKey_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *customerManagedEncryptionServiceClient) ListCustomerManagedEncryptionKeys(ctx context.Context, in *ListCustomerManagedEncryptionKeysRequest, opts ...grpc.CallOption) (*ListCustomerManagedEncryptionKeysResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListCustomerManagedEncryptionKeysResponse)
	err := c.cc.Invoke(ctx, CustomerManagedEncryptionService_ListCustomerManagedEncryptionKeys_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *customerManagedEncryptionServiceClient) DeleteCustomerManagedEncryptionKey(ctx context.Context, in *DeleteCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, CustomerManagedEncryptionService_DeleteCustomerManagedEncryptionKey_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *customerManagedEncryptionServiceClient) GetCmekAccessIamPrincipal(ctx context.Context, in *GetCmekAccessIamPrincipalRequest, opts ...grpc.CallOption) (*GetCmekAccessIamPrincipalResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetCmekAccessIamPrincipalResponse)
	err := c.cc.Invoke(ctx, CustomerManagedEncryptionService_GetCmekAccessIamPrincipal_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CustomerManagedEncryptionServiceServer is the server API for CustomerManagedEncryptionService service.
// All implementations should embed UnimplementedCustomerManagedEncryptionServiceServer
// for forward compatibility
type CustomerManagedEncryptionServiceServer interface {
	CreateCustomerManagedEncryptionKey(context.Context, *CreateCustomerManagedEncryptionKeyRequest) (*CustomerManagedEncryptionKey, error)
	GetCustomerManagedEncryptionKey(context.Context, *GetCustomerManagedEncryptionKeyRequest) (*CustomerManagedEncryptionKey, error)
	ListCustomerManagedEncryptionKeys(context.Context, *ListCustomerManagedEncryptionKeysRequest) (*ListCustomerManagedEncryptionKeysResponse, error)
	DeleteCustomerManagedEncryptionKey(context.Context, *DeleteCustomerManagedEncryptionKeyRequest) (*emptypb.Empty, error)
	GetCmekAccessIamPrincipal(context.Context, *GetCmekAccessIamPrincipalRequest) (*GetCmekAccessIamPrincipalResponse, error)
}

// UnimplementedCustomerManagedEncryptionServiceServer should be embedded to have forward compatible implementations.
type UnimplementedCustomerManagedEncryptionServiceServer struct {
}

func (UnimplementedCustomerManagedEncryptionServiceServer) CreateCustomerManagedEncryptionKey(context.Context, *CreateCustomerManagedEncryptionKeyRequest) (*CustomerManagedEncryptionKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCustomerManagedEncryptionKey not implemented")
}
func (UnimplementedCustomerManagedEncryptionServiceServer) GetCustomerManagedEncryptionKey(context.Context, *GetCustomerManagedEncryptionKeyRequest) (*CustomerManagedEncryptionKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCustomerManagedEncryptionKey not implemented")
}
func (UnimplementedCustomerManagedEncryptionServiceServer) ListCustomerManagedEncryptionKeys(context.Context, *ListCustomerManagedEncryptionKeysRequest) (*ListCustomerManagedEncryptionKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCustomerManagedEncryptionKeys not implemented")
}
func (UnimplementedCustomerManagedEncryptionServiceServer) DeleteCustomerManagedEncryptionKey(context.Context, *DeleteCustomerManagedEncryptionKeyRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCustomerManagedEncryptionKey not implemented")
}
func (UnimplementedCustomerManagedEncryptionServiceServer) GetCmekAccessIamPrincipal(context.Context, *GetCmekAccessIamPrincipalRequest) (*GetCmekAccessIamPrincipalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCmekAccessIamPrincipal not implemented")
}

// UnsafeCustomerManagedEncryptionServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CustomerManagedEncryptionServiceServer will
// result in compilation errors.
type UnsafeCustomerManagedEncryptionServiceServer interface {
	mustEmbedUnimplementedCustomerManagedEncryptionServiceServer()
}

func RegisterCustomerManagedEncryptionServiceServer(s grpc.ServiceRegistrar, srv CustomerManagedEncryptionServiceServer) {
	s.RegisterService(&CustomerManagedEncryptionService_ServiceDesc, srv)
}

func _CustomerManagedEncryptionService_CreateCustomerManagedEncryptionKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateCustomerManagedEncryptionKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CustomerManagedEncryptionServiceServer).CreateCustomerManagedEncryptionKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CustomerManagedEncryptionService_CreateCustomerManagedEncryptionKey_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CustomerManagedEncryptionServiceServer).CreateCustomerManagedEncryptionKey(ctx, req.(*CreateCustomerManagedEncryptionKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CustomerManagedEncryptionService_GetCustomerManagedEncryptionKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCustomerManagedEncryptionKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CustomerManagedEncryptionServiceServer).GetCustomerManagedEncryptionKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CustomerManagedEncryptionService_GetCustomerManagedEncryptionKey_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CustomerManagedEncryptionServiceServer).GetCustomerManagedEncryptionKey(ctx, req.(*GetCustomerManagedEncryptionKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CustomerManagedEncryptionService_ListCustomerManagedEncryptionKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCustomerManagedEncryptionKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CustomerManagedEncryptionServiceServer).ListCustomerManagedEncryptionKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CustomerManagedEncryptionService_ListCustomerManagedEncryptionKeys_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CustomerManagedEncryptionServiceServer).ListCustomerManagedEncryptionKeys(ctx, req.(*ListCustomerManagedEncryptionKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CustomerManagedEncryptionService_DeleteCustomerManagedEncryptionKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteCustomerManagedEncryptionKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CustomerManagedEncryptionServiceServer).DeleteCustomerManagedEncryptionKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CustomerManagedEncryptionService_DeleteCustomerManagedEncryptionKey_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CustomerManagedEncryptionServiceServer).DeleteCustomerManagedEncryptionKey(ctx, req.(*DeleteCustomerManagedEncryptionKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CustomerManagedEncryptionService_GetCmekAccessIamPrincipal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCmekAccessIamPrincipalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CustomerManagedEncryptionServiceServer).GetCmekAccessIamPrincipal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CustomerManagedEncryptionService_GetCmekAccessIamPrincipal_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CustomerManagedEncryptionServiceServer).GetCmekAccessIamPrincipal(ctx, req.(*GetCmekAccessIamPrincipalRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// CustomerManagedEncryptionService_ServiceDesc is the grpc.ServiceDesc for CustomerManagedEncryptionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CustomerManagedEncryptionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.CustomerManagedEncryptionService",
	HandlerType: (*CustomerManagedEncryptionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateCustomerManagedEncryptionKey",
			Handler:    _CustomerManagedEncryptionService_CreateCustomerManagedEncryptionKey_Handler,
		},
		{
			MethodName: "GetCustomerManagedEncryptionKey",
			Handler:    _CustomerManagedEncryptionService_GetCustomerManagedEncryptionKey_Handler,
		},
		{
			MethodName: "ListCustomerManagedEncryptionKeys",
			Handler:    _CustomerManagedEncryptionService_ListCustomerManagedEncryptionKeys_Handler,
		},
		{
			MethodName: "DeleteCustomerManagedEncryptionKey",
			Handler:    _CustomerManagedEncryptionService_DeleteCustomerManagedEncryptionKey_Handler,
		},
		{
			MethodName: "GetCmekAccessIamPrincipal",
			Handler:    _CustomerManagedEncryptionService_GetCmekAccessIamPrincipal_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	DatabaseAuditLogService_GetAuditLogConfig_FullMethodName                   = "/global.dedicated.v1.DatabaseAuditLogService/GetAuditLogConfig"
	DatabaseAuditLogService_UpdateAuditLogConfig_FullMethodName                = "/global.dedicated.v1.DatabaseAuditLogService/UpdateAuditLogConfig"
	DatabaseAuditLogService_PrecheckAuditLogConfig_FullMethodName              = "/global.dedicated.v1.DatabaseAuditLogService/PrecheckAuditLogConfig"
	DatabaseAuditLogService_ListAuditLogFilterRules_FullMethodName             = "/global.dedicated.v1.DatabaseAuditLogService/ListAuditLogFilterRules"
	DatabaseAuditLogService_CreateAuditLogFilterRule_FullMethodName            = "/global.dedicated.v1.DatabaseAuditLogService/CreateAuditLogFilterRule"
	DatabaseAuditLogService_DeleteAuditLogFilterRule_FullMethodName            = "/global.dedicated.v1.DatabaseAuditLogService/DeleteAuditLogFilterRule"
	DatabaseAuditLogService_ReplaceAuditLogFilterRule_FullMethodName           = "/global.dedicated.v1.DatabaseAuditLogService/ReplaceAuditLogFilterRule"
	DatabaseAuditLogService_GetAccount_FullMethodName                          = "/global.dedicated.v1.DatabaseAuditLogService/GetAccount"
	DatabaseAuditLogService_QueryAuditLogFiles_FullMethodName                  = "/global.dedicated.v1.DatabaseAuditLogService/QueryAuditLogFiles"
	DatabaseAuditLogService_GenerateAuditLogFileDownloadAddress_FullMethodName = "/global.dedicated.v1.DatabaseAuditLogService/GenerateAuditLogFileDownloadAddress"
)

// DatabaseAuditLogServiceClient is the client API for DatabaseAuditLogService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DatabaseAuditLogServiceClient interface {
	GetAuditLogConfig(ctx context.Context, in *GetAuditLogConfigRequest, opts ...grpc.CallOption) (*AuditLogConfig, error)
	UpdateAuditLogConfig(ctx context.Context, in *UpdateAuditLogConfigRequest, opts ...grpc.CallOption) (*AuditLogConfig, error)
	PrecheckAuditLogConfig(ctx context.Context, in *PrecheckAuditLogConfigRequest, opts ...grpc.CallOption) (*PrecheckAuditLogConfigResponse, error)
	ListAuditLogFilterRules(ctx context.Context, in *ListAuditLogFilterRulesRequest, opts ...grpc.CallOption) (*ListAuditLogFilterRulesResponse, error)
	CreateAuditLogFilterRule(ctx context.Context, in *CreateAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*AuditLogFilterRule, error)
	DeleteAuditLogFilterRule(ctx context.Context, in *DeleteAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ReplaceAuditLogFilterRule(ctx context.Context, in *ReplaceAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*AuditLogFilterRule, error)
	GetAccount(ctx context.Context, in *GetAccountRequest, opts ...grpc.CallOption) (*GetAccountResponse, error)
	QueryAuditLogFiles(ctx context.Context, in *QueryAuditLogFilesRequest, opts ...grpc.CallOption) (*QueryAuditLogFilesResponse, error)
	GenerateAuditLogFileDownloadAddress(ctx context.Context, in *GenerateAuditLogFileDownloadAddressRequest, opts ...grpc.CallOption) (*GenerateAuditLogFileDownloadAddressResponse, error)
}

type databaseAuditLogServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDatabaseAuditLogServiceClient(cc grpc.ClientConnInterface) DatabaseAuditLogServiceClient {
	return &databaseAuditLogServiceClient{cc}
}

func (c *databaseAuditLogServiceClient) GetAuditLogConfig(ctx context.Context, in *GetAuditLogConfigRequest, opts ...grpc.CallOption) (*AuditLogConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AuditLogConfig)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_GetAuditLogConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) UpdateAuditLogConfig(ctx context.Context, in *UpdateAuditLogConfigRequest, opts ...grpc.CallOption) (*AuditLogConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AuditLogConfig)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_UpdateAuditLogConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) PrecheckAuditLogConfig(ctx context.Context, in *PrecheckAuditLogConfigRequest, opts ...grpc.CallOption) (*PrecheckAuditLogConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PrecheckAuditLogConfigResponse)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_PrecheckAuditLogConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) ListAuditLogFilterRules(ctx context.Context, in *ListAuditLogFilterRulesRequest, opts ...grpc.CallOption) (*ListAuditLogFilterRulesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAuditLogFilterRulesResponse)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_ListAuditLogFilterRules_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) CreateAuditLogFilterRule(ctx context.Context, in *CreateAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*AuditLogFilterRule, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AuditLogFilterRule)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_CreateAuditLogFilterRule_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) DeleteAuditLogFilterRule(ctx context.Context, in *DeleteAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_DeleteAuditLogFilterRule_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) ReplaceAuditLogFilterRule(ctx context.Context, in *ReplaceAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*AuditLogFilterRule, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AuditLogFilterRule)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_ReplaceAuditLogFilterRule_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) GetAccount(ctx context.Context, in *GetAccountRequest, opts ...grpc.CallOption) (*GetAccountResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetAccountResponse)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_GetAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) QueryAuditLogFiles(ctx context.Context, in *QueryAuditLogFilesRequest, opts ...grpc.CallOption) (*QueryAuditLogFilesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(QueryAuditLogFilesResponse)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_QueryAuditLogFiles_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *databaseAuditLogServiceClient) GenerateAuditLogFileDownloadAddress(ctx context.Context, in *GenerateAuditLogFileDownloadAddressRequest, opts ...grpc.CallOption) (*GenerateAuditLogFileDownloadAddressResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GenerateAuditLogFileDownloadAddressResponse)
	err := c.cc.Invoke(ctx, DatabaseAuditLogService_GenerateAuditLogFileDownloadAddress_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DatabaseAuditLogServiceServer is the server API for DatabaseAuditLogService service.
// All implementations should embed UnimplementedDatabaseAuditLogServiceServer
// for forward compatibility
type DatabaseAuditLogServiceServer interface {
	GetAuditLogConfig(context.Context, *GetAuditLogConfigRequest) (*AuditLogConfig, error)
	UpdateAuditLogConfig(context.Context, *UpdateAuditLogConfigRequest) (*AuditLogConfig, error)
	PrecheckAuditLogConfig(context.Context, *PrecheckAuditLogConfigRequest) (*PrecheckAuditLogConfigResponse, error)
	ListAuditLogFilterRules(context.Context, *ListAuditLogFilterRulesRequest) (*ListAuditLogFilterRulesResponse, error)
	CreateAuditLogFilterRule(context.Context, *CreateAuditLogFilterRuleRequest) (*AuditLogFilterRule, error)
	DeleteAuditLogFilterRule(context.Context, *DeleteAuditLogFilterRuleRequest) (*emptypb.Empty, error)
	ReplaceAuditLogFilterRule(context.Context, *ReplaceAuditLogFilterRuleRequest) (*AuditLogFilterRule, error)
	GetAccount(context.Context, *GetAccountRequest) (*GetAccountResponse, error)
	QueryAuditLogFiles(context.Context, *QueryAuditLogFilesRequest) (*QueryAuditLogFilesResponse, error)
	GenerateAuditLogFileDownloadAddress(context.Context, *GenerateAuditLogFileDownloadAddressRequest) (*GenerateAuditLogFileDownloadAddressResponse, error)
}

// UnimplementedDatabaseAuditLogServiceServer should be embedded to have forward compatible implementations.
type UnimplementedDatabaseAuditLogServiceServer struct {
}

func (UnimplementedDatabaseAuditLogServiceServer) GetAuditLogConfig(context.Context, *GetAuditLogConfigRequest) (*AuditLogConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAuditLogConfig not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) UpdateAuditLogConfig(context.Context, *UpdateAuditLogConfigRequest) (*AuditLogConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAuditLogConfig not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) PrecheckAuditLogConfig(context.Context, *PrecheckAuditLogConfigRequest) (*PrecheckAuditLogConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PrecheckAuditLogConfig not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) ListAuditLogFilterRules(context.Context, *ListAuditLogFilterRulesRequest) (*ListAuditLogFilterRulesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAuditLogFilterRules not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) CreateAuditLogFilterRule(context.Context, *CreateAuditLogFilterRuleRequest) (*AuditLogFilterRule, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAuditLogFilterRule not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) DeleteAuditLogFilterRule(context.Context, *DeleteAuditLogFilterRuleRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAuditLogFilterRule not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) ReplaceAuditLogFilterRule(context.Context, *ReplaceAuditLogFilterRuleRequest) (*AuditLogFilterRule, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplaceAuditLogFilterRule not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) GetAccount(context.Context, *GetAccountRequest) (*GetAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccount not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) QueryAuditLogFiles(context.Context, *QueryAuditLogFilesRequest) (*QueryAuditLogFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryAuditLogFiles not implemented")
}
func (UnimplementedDatabaseAuditLogServiceServer) GenerateAuditLogFileDownloadAddress(context.Context, *GenerateAuditLogFileDownloadAddressRequest) (*GenerateAuditLogFileDownloadAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateAuditLogFileDownloadAddress not implemented")
}

// UnsafeDatabaseAuditLogServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DatabaseAuditLogServiceServer will
// result in compilation errors.
type UnsafeDatabaseAuditLogServiceServer interface {
	mustEmbedUnimplementedDatabaseAuditLogServiceServer()
}

func RegisterDatabaseAuditLogServiceServer(s grpc.ServiceRegistrar, srv DatabaseAuditLogServiceServer) {
	s.RegisterService(&DatabaseAuditLogService_ServiceDesc, srv)
}

func _DatabaseAuditLogService_GetAuditLogConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAuditLogConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).GetAuditLogConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_GetAuditLogConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).GetAuditLogConfig(ctx, req.(*GetAuditLogConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_UpdateAuditLogConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAuditLogConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).UpdateAuditLogConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_UpdateAuditLogConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).UpdateAuditLogConfig(ctx, req.(*UpdateAuditLogConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_PrecheckAuditLogConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrecheckAuditLogConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).PrecheckAuditLogConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_PrecheckAuditLogConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).PrecheckAuditLogConfig(ctx, req.(*PrecheckAuditLogConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_ListAuditLogFilterRules_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAuditLogFilterRulesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).ListAuditLogFilterRules(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_ListAuditLogFilterRules_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).ListAuditLogFilterRules(ctx, req.(*ListAuditLogFilterRulesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_CreateAuditLogFilterRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAuditLogFilterRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).CreateAuditLogFilterRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_CreateAuditLogFilterRule_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).CreateAuditLogFilterRule(ctx, req.(*CreateAuditLogFilterRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_DeleteAuditLogFilterRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAuditLogFilterRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).DeleteAuditLogFilterRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_DeleteAuditLogFilterRule_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).DeleteAuditLogFilterRule(ctx, req.(*DeleteAuditLogFilterRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_ReplaceAuditLogFilterRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplaceAuditLogFilterRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).ReplaceAuditLogFilterRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_ReplaceAuditLogFilterRule_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).ReplaceAuditLogFilterRule(ctx, req.(*ReplaceAuditLogFilterRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_GetAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).GetAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_GetAccount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).GetAccount(ctx, req.(*GetAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_QueryAuditLogFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAuditLogFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).QueryAuditLogFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_QueryAuditLogFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).QueryAuditLogFiles(ctx, req.(*QueryAuditLogFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatabaseAuditLogService_GenerateAuditLogFileDownloadAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateAuditLogFileDownloadAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatabaseAuditLogServiceServer).GenerateAuditLogFileDownloadAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DatabaseAuditLogService_GenerateAuditLogFileDownloadAddress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatabaseAuditLogServiceServer).GenerateAuditLogFileDownloadAddress(ctx, req.(*GenerateAuditLogFileDownloadAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DatabaseAuditLogService_ServiceDesc is the grpc.ServiceDesc for DatabaseAuditLogService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DatabaseAuditLogService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.DatabaseAuditLogService",
	HandlerType: (*DatabaseAuditLogServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAuditLogConfig",
			Handler:    _DatabaseAuditLogService_GetAuditLogConfig_Handler,
		},
		{
			MethodName: "UpdateAuditLogConfig",
			Handler:    _DatabaseAuditLogService_UpdateAuditLogConfig_Handler,
		},
		{
			MethodName: "PrecheckAuditLogConfig",
			Handler:    _DatabaseAuditLogService_PrecheckAuditLogConfig_Handler,
		},
		{
			MethodName: "ListAuditLogFilterRules",
			Handler:    _DatabaseAuditLogService_ListAuditLogFilterRules_Handler,
		},
		{
			MethodName: "CreateAuditLogFilterRule",
			Handler:    _DatabaseAuditLogService_CreateAuditLogFilterRule_Handler,
		},
		{
			MethodName: "DeleteAuditLogFilterRule",
			Handler:    _DatabaseAuditLogService_DeleteAuditLogFilterRule_Handler,
		},
		{
			MethodName: "ReplaceAuditLogFilterRule",
			Handler:    _DatabaseAuditLogService_ReplaceAuditLogFilterRule_Handler,
		},
		{
			MethodName: "GetAccount",
			Handler:    _DatabaseAuditLogService_GetAccount_Handler,
		},
		{
			MethodName: "QueryAuditLogFiles",
			Handler:    _DatabaseAuditLogService_QueryAuditLogFiles_Handler,
		},
		{
			MethodName: "GenerateAuditLogFileDownloadAddress",
			Handler:    _DatabaseAuditLogService_GenerateAuditLogFileDownloadAddress_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}

const (
	MeteringService_CalcClusterFee_FullMethodName = "/global.dedicated.v1.MeteringService/CalcClusterFee"
)

// MeteringServiceClient is the client API for MeteringService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type MeteringServiceClient interface {
	CalcClusterFee(ctx context.Context, in *CalcClusterFeeRequest, opts ...grpc.CallOption) (*CalcClusterFeeResponse, error)
}

type meteringServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewMeteringServiceClient(cc grpc.ClientConnInterface) MeteringServiceClient {
	return &meteringServiceClient{cc}
}

func (c *meteringServiceClient) CalcClusterFee(ctx context.Context, in *CalcClusterFeeRequest, opts ...grpc.CallOption) (*CalcClusterFeeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CalcClusterFeeResponse)
	err := c.cc.Invoke(ctx, MeteringService_CalcClusterFee_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MeteringServiceServer is the server API for MeteringService service.
// All implementations should embed UnimplementedMeteringServiceServer
// for forward compatibility
type MeteringServiceServer interface {
	CalcClusterFee(context.Context, *CalcClusterFeeRequest) (*CalcClusterFeeResponse, error)
}

// UnimplementedMeteringServiceServer should be embedded to have forward compatible implementations.
type UnimplementedMeteringServiceServer struct {
}

func (UnimplementedMeteringServiceServer) CalcClusterFee(context.Context, *CalcClusterFeeRequest) (*CalcClusterFeeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CalcClusterFee not implemented")
}

// UnsafeMeteringServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to MeteringServiceServer will
// result in compilation errors.
type UnsafeMeteringServiceServer interface {
	mustEmbedUnimplementedMeteringServiceServer()
}

func RegisterMeteringServiceServer(s grpc.ServiceRegistrar, srv MeteringServiceServer) {
	s.RegisterService(&MeteringService_ServiceDesc, srv)
}

func _MeteringService_CalcClusterFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CalcClusterFeeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MeteringServiceServer).CalcClusterFee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MeteringService_CalcClusterFee_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MeteringServiceServer).CalcClusterFee(ctx, req.(*CalcClusterFeeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// MeteringService_ServiceDesc is the grpc.ServiceDesc for MeteringService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var MeteringService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.dedicated.v1.MeteringService",
	HandlerType: (*MeteringServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CalcClusterFee",
			Handler:    _MeteringService_CalcClusterFee_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/dedicated/v1/services.proto",
}
