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

package tidb_mgmt_servicev1

import (
	context "context"
	v11 "github.com/tidbcloud/tidb-management-service/api/spec/global/dedicated/v1"
	v1 "github.com/tidbcloud/tidb-management-service/api/spec/global/nextgen/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_ListClusters_FullMethodName                               = "/tidb_mgmt_service.v1.ClusterService/ListClusters"
	ClusterService_CountClusters_FullMethodName                              = "/tidb_mgmt_service.v1.ClusterService/CountClusters"
	ClusterService_CleanClusters_FullMethodName                              = "/tidb_mgmt_service.v1.ClusterService/CleanClusters"
	ClusterService_CleanProjectResource_FullMethodName                       = "/tidb_mgmt_service.v1.ClusterService/CleanProjectResource"
	ClusterService_CleanOrganizationResource_FullMethodName                  = "/tidb_mgmt_service.v1.ClusterService/CleanOrganizationResource"
	ClusterService_ApplyCluster_FullMethodName                               = "/tidb_mgmt_service.v1.ClusterService/ApplyCluster"
	ClusterService_ApplyGKEHeterogeneousDeploy_FullMethodName                = "/tidb_mgmt_service.v1.ClusterService/ApplyGKEHeterogeneousDeploy"
	ClusterService_GetGKEHeterogeneousDeploy_FullMethodName                  = "/tidb_mgmt_service.v1.ClusterService/GetGKEHeterogeneousDeploy"
	ClusterService_DeleteGKEHeterogeneousDeploy_FullMethodName               = "/tidb_mgmt_service.v1.ClusterService/DeleteGKEHeterogeneousDeploy"
	ClusterService_RestoreDedicatedCluster_FullMethodName                    = "/tidb_mgmt_service.v1.ClusterService/RestoreDedicatedCluster"
	ClusterService_RestoreServerlessCluster_FullMethodName                   = "/tidb_mgmt_service.v1.ClusterService/RestoreServerlessCluster"
	ClusterService_CreateServerlessCluster_FullMethodName                    = "/tidb_mgmt_service.v1.ClusterService/CreateServerlessCluster"
	ClusterService_UpdateServerlessRegionalClusterAnnotations_FullMethodName = "/tidb_mgmt_service.v1.ClusterService/UpdateServerlessRegionalClusterAnnotations"
	ClusterService_DeleteCluster_FullMethodName                              = "/tidb_mgmt_service.v1.ClusterService/DeleteCluster"
	ClusterService_ModifyClusterVolume_FullMethodName                        = "/tidb_mgmt_service.v1.ClusterService/ModifyClusterVolume"
	ClusterService_ScaleClusterPdComponent_FullMethodName                    = "/tidb_mgmt_service.v1.ClusterService/ScaleClusterPdComponent"
	ClusterService_ScaleClusterTiProxyComponent_FullMethodName               = "/tidb_mgmt_service.v1.ClusterService/ScaleClusterTiProxyComponent"
	ClusterService_ScaleClusterComponents_FullMethodName                     = "/tidb_mgmt_service.v1.ClusterService/ScaleClusterComponents"
	ClusterService_CreateClusterWithClusterConfiguration_FullMethodName      = "/tidb_mgmt_service.v1.ClusterService/CreateClusterWithClusterConfiguration"
	ClusterService_ShowComponentNodeInfo_FullMethodName                      = "/tidb_mgmt_service.v1.ClusterService/ShowComponentNodeInfo"
	ClusterService_CountBillableClusters_FullMethodName                      = "/tidb_mgmt_service.v1.ClusterService/CountBillableClusters"
	ClusterService_BuildComponentSpecDiffReports_FullMethodName              = "/tidb_mgmt_service.v1.ClusterService/BuildComponentSpecDiffReports"
	ClusterService_GetCloudIamInfo_FullMethodName                            = "/tidb_mgmt_service.v1.ClusterService/GetCloudIamInfo"
	ClusterService_UpdateClusterRuVersion_FullMethodName                     = "/tidb_mgmt_service.v1.ClusterService/UpdateClusterRuVersion"
	ClusterService_AddClusterLabels_FullMethodName                           = "/tidb_mgmt_service.v1.ClusterService/AddClusterLabels"
)

// 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 {
	ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error)
	CountClusters(ctx context.Context, in *CountClustersRequest, opts ...grpc.CallOption) (*CountClustersResponse, error)
	// Success means deletion workflows were submitted for all matching clusters.
	// Resource deletion continues asynchronously.
	CleanClusters(ctx context.Context, in *CleanClustersRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CleanProjectResource(ctx context.Context, in *CleanProjectResourceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CleanOrganizationResource(ctx context.Context, in *CleanOrganizationResourceRequest, opts ...grpc.CallOption) (*emptypb.Empty, 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)
	RestoreDedicatedCluster(ctx context.Context, in *RestoreDedicatedClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	RestoreServerlessCluster(ctx context.Context, in *RestoreServerlessClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	CreateServerlessCluster(ctx context.Context, in *CreateServerlessClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	// return basic view cluster
	UpdateServerlessRegionalClusterAnnotations(ctx context.Context, in *UpdateServerlessRegionalClusterAnnotationsRequest, opts ...grpc.CallOption) (*Cluster, error)
	DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
	ModifyClusterVolume(ctx context.Context, in *ModifyClusterVolumeRequest, opts ...grpc.CallOption) (*Cluster, error)
	ScaleClusterPdComponent(ctx context.Context, in *ScaleClusterPdComponentRequest, opts ...grpc.CallOption) (*Cluster, error)
	ScaleClusterTiProxyComponent(ctx context.Context, in *ScaleClusterTiProxyComponentRequest, opts ...grpc.CallOption) (*Cluster, error)
	ScaleClusterComponents(ctx context.Context, in *ScaleClusterComponentsRequest, opts ...grpc.CallOption) (*Cluster, error)
	CreateClusterWithClusterConfiguration(ctx context.Context, in *CreateClusterWithClusterConfigurationRequest, opts ...grpc.CallOption) (*Cluster, error)
	ShowComponentNodeInfo(ctx context.Context, in *ShowComponentNodeInfoRequest, opts ...grpc.CallOption) (*ShowComponentNodeInfoResponse, error)
	CountBillableClusters(ctx context.Context, in *CountBillableClustersRequest, opts ...grpc.CallOption) (*CountBillableClustersResponse, error)
	BuildComponentSpecDiffReports(ctx context.Context, in *BuildComponentSpecDiffReportsRequest, opts ...grpc.CallOption) (*BuildComponentSpecDiffReportsResponse, error)
	GetCloudIamInfo(ctx context.Context, in *GetCloudIamInfoRequest, opts ...grpc.CallOption) (*CloudIamInfo, error)
	// Update ru_version for a cluster (Essential or Premium). Internal ops only.
	UpdateClusterRuVersion(ctx context.Context, in *UpdateClusterRuVersionRequest, opts ...grpc.CallOption) (*Cluster, error)
	AddClusterLabels(ctx context.Context, in *AddClusterLabelsRequest, opts ...grpc.CallOption) (*Cluster, error)
}

type clusterServiceClient struct {
	cc grpc.ClientConnInterface
}

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

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) CountClusters(ctx context.Context, in *CountClustersRequest, opts ...grpc.CallOption) (*CountClustersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountClustersResponse)
	err := c.cc.Invoke(ctx, ClusterService_CountClusters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *clusterServiceClient) CleanOrganizationResource(ctx context.Context, in *CleanOrganizationResourceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ClusterService_CleanOrganizationResource_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) RestoreDedicatedCluster(ctx context.Context, in *RestoreDedicatedClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_RestoreDedicatedCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *clusterServiceClient) UpdateServerlessRegionalClusterAnnotations(ctx context.Context, in *UpdateServerlessRegionalClusterAnnotationsRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_UpdateServerlessRegionalClusterAnnotations_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) ModifyClusterVolume(ctx context.Context, in *ModifyClusterVolumeRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_ModifyClusterVolume_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

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

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

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

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

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

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

func (c *clusterServiceClient) AddClusterLabels(ctx context.Context, in *AddClusterLabelsRequest, opts ...grpc.CallOption) (*Cluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Cluster)
	err := c.cc.Invoke(ctx, ClusterService_AddClusterLabels_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 {
	ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error)
	CountClusters(context.Context, *CountClustersRequest) (*CountClustersResponse, error)
	// Success means deletion workflows were submitted for all matching clusters.
	// Resource deletion continues asynchronously.
	CleanClusters(context.Context, *CleanClustersRequest) (*emptypb.Empty, error)
	CleanProjectResource(context.Context, *CleanProjectResourceRequest) (*emptypb.Empty, error)
	CleanOrganizationResource(context.Context, *CleanOrganizationResourceRequest) (*emptypb.Empty, 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)
	RestoreDedicatedCluster(context.Context, *RestoreDedicatedClusterRequest) (*Cluster, error)
	RestoreServerlessCluster(context.Context, *RestoreServerlessClusterRequest) (*Cluster, error)
	CreateServerlessCluster(context.Context, *CreateServerlessClusterRequest) (*Cluster, error)
	// return basic view cluster
	UpdateServerlessRegionalClusterAnnotations(context.Context, *UpdateServerlessRegionalClusterAnnotationsRequest) (*Cluster, error)
	DeleteCluster(context.Context, *DeleteClusterRequest) (*Cluster, error)
	ModifyClusterVolume(context.Context, *ModifyClusterVolumeRequest) (*Cluster, error)
	ScaleClusterPdComponent(context.Context, *ScaleClusterPdComponentRequest) (*Cluster, error)
	ScaleClusterTiProxyComponent(context.Context, *ScaleClusterTiProxyComponentRequest) (*Cluster, error)
	ScaleClusterComponents(context.Context, *ScaleClusterComponentsRequest) (*Cluster, error)
	CreateClusterWithClusterConfiguration(context.Context, *CreateClusterWithClusterConfigurationRequest) (*Cluster, error)
	ShowComponentNodeInfo(context.Context, *ShowComponentNodeInfoRequest) (*ShowComponentNodeInfoResponse, error)
	CountBillableClusters(context.Context, *CountBillableClustersRequest) (*CountBillableClustersResponse, error)
	BuildComponentSpecDiffReports(context.Context, *BuildComponentSpecDiffReportsRequest) (*BuildComponentSpecDiffReportsResponse, error)
	GetCloudIamInfo(context.Context, *GetCloudIamInfoRequest) (*CloudIamInfo, error)
	// Update ru_version for a cluster (Essential or Premium). Internal ops only.
	UpdateClusterRuVersion(context.Context, *UpdateClusterRuVersionRequest) (*Cluster, error)
	AddClusterLabels(context.Context, *AddClusterLabelsRequest) (*Cluster, error)
}

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

func (UnimplementedClusterServiceServer) ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClusters not implemented")
}
func (UnimplementedClusterServiceServer) CountClusters(context.Context, *CountClustersRequest) (*CountClustersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountClusters not implemented")
}
func (UnimplementedClusterServiceServer) CleanClusters(context.Context, *CleanClustersRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CleanClusters not implemented")
}
func (UnimplementedClusterServiceServer) CleanProjectResource(context.Context, *CleanProjectResourceRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CleanProjectResource not implemented")
}
func (UnimplementedClusterServiceServer) CleanOrganizationResource(context.Context, *CleanOrganizationResourceRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CleanOrganizationResource 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) RestoreDedicatedCluster(context.Context, *RestoreDedicatedClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestoreDedicatedCluster not implemented")
}
func (UnimplementedClusterServiceServer) RestoreServerlessCluster(context.Context, *RestoreServerlessClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestoreServerlessCluster not implemented")
}
func (UnimplementedClusterServiceServer) CreateServerlessCluster(context.Context, *CreateServerlessClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateServerlessCluster not implemented")
}
func (UnimplementedClusterServiceServer) UpdateServerlessRegionalClusterAnnotations(context.Context, *UpdateServerlessRegionalClusterAnnotationsRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateServerlessRegionalClusterAnnotations not implemented")
}
func (UnimplementedClusterServiceServer) DeleteCluster(context.Context, *DeleteClusterRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCluster not implemented")
}
func (UnimplementedClusterServiceServer) ModifyClusterVolume(context.Context, *ModifyClusterVolumeRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyClusterVolume not implemented")
}
func (UnimplementedClusterServiceServer) ScaleClusterPdComponent(context.Context, *ScaleClusterPdComponentRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ScaleClusterPdComponent not implemented")
}
func (UnimplementedClusterServiceServer) ScaleClusterTiProxyComponent(context.Context, *ScaleClusterTiProxyComponentRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ScaleClusterTiProxyComponent not implemented")
}
func (UnimplementedClusterServiceServer) ScaleClusterComponents(context.Context, *ScaleClusterComponentsRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ScaleClusterComponents not implemented")
}
func (UnimplementedClusterServiceServer) CreateClusterWithClusterConfiguration(context.Context, *CreateClusterWithClusterConfigurationRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateClusterWithClusterConfiguration not implemented")
}
func (UnimplementedClusterServiceServer) ShowComponentNodeInfo(context.Context, *ShowComponentNodeInfoRequest) (*ShowComponentNodeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShowComponentNodeInfo not implemented")
}
func (UnimplementedClusterServiceServer) CountBillableClusters(context.Context, *CountBillableClustersRequest) (*CountBillableClustersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountBillableClusters not implemented")
}
func (UnimplementedClusterServiceServer) BuildComponentSpecDiffReports(context.Context, *BuildComponentSpecDiffReportsRequest) (*BuildComponentSpecDiffReportsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BuildComponentSpecDiffReports not implemented")
}
func (UnimplementedClusterServiceServer) GetCloudIamInfo(context.Context, *GetCloudIamInfoRequest) (*CloudIamInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCloudIamInfo not implemented")
}
func (UnimplementedClusterServiceServer) UpdateClusterRuVersion(context.Context, *UpdateClusterRuVersionRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateClusterRuVersion not implemented")
}
func (UnimplementedClusterServiceServer) AddClusterLabels(context.Context, *AddClusterLabelsRequest) (*Cluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddClusterLabels 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_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_CountClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountClustersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).CountClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_CountClusters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).CountClusters(ctx, req.(*CountClustersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

func _ClusterService_CleanOrganizationResource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CleanOrganizationResourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).CleanOrganizationResource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_CleanOrganizationResource_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).CleanOrganizationResource(ctx, req.(*CleanOrganizationResourceRequest))
	}
	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_RestoreDedicatedCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestoreDedicatedClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).RestoreDedicatedCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_RestoreDedicatedCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).RestoreDedicatedCluster(ctx, req.(*RestoreDedicatedClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

func _ClusterService_UpdateServerlessRegionalClusterAnnotations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateServerlessRegionalClusterAnnotationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).UpdateServerlessRegionalClusterAnnotations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_UpdateServerlessRegionalClusterAnnotations_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).UpdateServerlessRegionalClusterAnnotations(ctx, req.(*UpdateServerlessRegionalClusterAnnotationsRequest))
	}
	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_ModifyClusterVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyClusterVolumeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).ModifyClusterVolume(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_ModifyClusterVolume_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).ModifyClusterVolume(ctx, req.(*ModifyClusterVolumeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

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

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

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

func _ClusterService_AddClusterLabels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddClusterLabelsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServiceServer).AddClusterLabels(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterService_AddClusterLabels_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServiceServer).AddClusterLabels(ctx, req.(*AddClusterLabelsRequest))
	}
	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: "tidb_mgmt_service.v1.ClusterService",
	HandlerType: (*ClusterServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListClusters",
			Handler:    _ClusterService_ListClusters_Handler,
		},
		{
			MethodName: "CountClusters",
			Handler:    _ClusterService_CountClusters_Handler,
		},
		{
			MethodName: "CleanClusters",
			Handler:    _ClusterService_CleanClusters_Handler,
		},
		{
			MethodName: "CleanProjectResource",
			Handler:    _ClusterService_CleanProjectResource_Handler,
		},
		{
			MethodName: "CleanOrganizationResource",
			Handler:    _ClusterService_CleanOrganizationResource_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: "RestoreDedicatedCluster",
			Handler:    _ClusterService_RestoreDedicatedCluster_Handler,
		},
		{
			MethodName: "RestoreServerlessCluster",
			Handler:    _ClusterService_RestoreServerlessCluster_Handler,
		},
		{
			MethodName: "CreateServerlessCluster",
			Handler:    _ClusterService_CreateServerlessCluster_Handler,
		},
		{
			MethodName: "UpdateServerlessRegionalClusterAnnotations",
			Handler:    _ClusterService_UpdateServerlessRegionalClusterAnnotations_Handler,
		},
		{
			MethodName: "DeleteCluster",
			Handler:    _ClusterService_DeleteCluster_Handler,
		},
		{
			MethodName: "ModifyClusterVolume",
			Handler:    _ClusterService_ModifyClusterVolume_Handler,
		},
		{
			MethodName: "ScaleClusterPdComponent",
			Handler:    _ClusterService_ScaleClusterPdComponent_Handler,
		},
		{
			MethodName: "ScaleClusterTiProxyComponent",
			Handler:    _ClusterService_ScaleClusterTiProxyComponent_Handler,
		},
		{
			MethodName: "ScaleClusterComponents",
			Handler:    _ClusterService_ScaleClusterComponents_Handler,
		},
		{
			MethodName: "CreateClusterWithClusterConfiguration",
			Handler:    _ClusterService_CreateClusterWithClusterConfiguration_Handler,
		},
		{
			MethodName: "ShowComponentNodeInfo",
			Handler:    _ClusterService_ShowComponentNodeInfo_Handler,
		},
		{
			MethodName: "CountBillableClusters",
			Handler:    _ClusterService_CountBillableClusters_Handler,
		},
		{
			MethodName: "BuildComponentSpecDiffReports",
			Handler:    _ClusterService_BuildComponentSpecDiffReports_Handler,
		},
		{
			MethodName: "GetCloudIamInfo",
			Handler:    _ClusterService_GetCloudIamInfo_Handler,
		},
		{
			MethodName: "UpdateClusterRuVersion",
			Handler:    _ClusterService_UpdateClusterRuVersion_Handler,
		},
		{
			MethodName: "AddClusterLabels",
			Handler:    _ClusterService_AddClusterLabels_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/services.proto",
}

const (
	ClusterCustomStatusService_SetClusterCustomStatus_FullMethodName       = "/tidb_mgmt_service.v1.ClusterCustomStatusService/SetClusterCustomStatus"
	ClusterCustomStatusService_GetClusterCustomStatusByID_FullMethodName   = "/tidb_mgmt_service.v1.ClusterCustomStatusService/GetClusterCustomStatusByID"
	ClusterCustomStatusService_GetClusterCustomStatusByName_FullMethodName = "/tidb_mgmt_service.v1.ClusterCustomStatusService/GetClusterCustomStatusByName"
	ClusterCustomStatusService_DeleteClusterCustomStatus_FullMethodName    = "/tidb_mgmt_service.v1.ClusterCustomStatusService/DeleteClusterCustomStatus"
	ClusterCustomStatusService_IsClusterCustomStatusExisted_FullMethodName = "/tidb_mgmt_service.v1.ClusterCustomStatusService/IsClusterCustomStatusExisted"
	ClusterCustomStatusService_ListClusterCustomStatus_FullMethodName      = "/tidb_mgmt_service.v1.ClusterCustomStatusService/ListClusterCustomStatus"
)

// ClusterCustomStatusServiceClient is the client API for ClusterCustomStatusService 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 ClusterCustomStatusServiceClient interface {
	SetClusterCustomStatus(ctx context.Context, in *SetClusterCustomStatusRequest, opts ...grpc.CallOption) (*ClusterCustomStatus, error)
	GetClusterCustomStatusByID(ctx context.Context, in *GetClusterCustomStatusByIDRequest, opts ...grpc.CallOption) (*ClusterCustomStatus, error)
	GetClusterCustomStatusByName(ctx context.Context, in *GetClusterCustomStatusByNameRequest, opts ...grpc.CallOption) (*ClusterCustomStatus, error)
	DeleteClusterCustomStatus(ctx context.Context, in *DeleteClusterCustomStatusRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	IsClusterCustomStatusExisted(ctx context.Context, in *IsClusterCustomStatusExistedRequest, opts ...grpc.CallOption) (*IsClusterCustomStatusExistedResponse, error)
	ListClusterCustomStatus(ctx context.Context, in *ListClusterCustomStatusRequest, opts ...grpc.CallOption) (*ListClusterCustomStatusResponse, error)
}

type clusterCustomStatusServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewClusterCustomStatusServiceClient(cc grpc.ClientConnInterface) ClusterCustomStatusServiceClient {
	return &clusterCustomStatusServiceClient{cc}
}

func (c *clusterCustomStatusServiceClient) SetClusterCustomStatus(ctx context.Context, in *SetClusterCustomStatusRequest, opts ...grpc.CallOption) (*ClusterCustomStatus, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClusterCustomStatus)
	err := c.cc.Invoke(ctx, ClusterCustomStatusService_SetClusterCustomStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterCustomStatusServiceClient) GetClusterCustomStatusByID(ctx context.Context, in *GetClusterCustomStatusByIDRequest, opts ...grpc.CallOption) (*ClusterCustomStatus, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClusterCustomStatus)
	err := c.cc.Invoke(ctx, ClusterCustomStatusService_GetClusterCustomStatusByID_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterCustomStatusServiceClient) GetClusterCustomStatusByName(ctx context.Context, in *GetClusterCustomStatusByNameRequest, opts ...grpc.CallOption) (*ClusterCustomStatus, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClusterCustomStatus)
	err := c.cc.Invoke(ctx, ClusterCustomStatusService_GetClusterCustomStatusByName_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *clusterCustomStatusServiceClient) IsClusterCustomStatusExisted(ctx context.Context, in *IsClusterCustomStatusExistedRequest, opts ...grpc.CallOption) (*IsClusterCustomStatusExistedResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IsClusterCustomStatusExistedResponse)
	err := c.cc.Invoke(ctx, ClusterCustomStatusService_IsClusterCustomStatusExisted_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterCustomStatusServiceClient) ListClusterCustomStatus(ctx context.Context, in *ListClusterCustomStatusRequest, opts ...grpc.CallOption) (*ListClusterCustomStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListClusterCustomStatusResponse)
	err := c.cc.Invoke(ctx, ClusterCustomStatusService_ListClusterCustomStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ClusterCustomStatusServiceServer is the server API for ClusterCustomStatusService service.
// All implementations should embed UnimplementedClusterCustomStatusServiceServer
// for forward compatibility
type ClusterCustomStatusServiceServer interface {
	SetClusterCustomStatus(context.Context, *SetClusterCustomStatusRequest) (*ClusterCustomStatus, error)
	GetClusterCustomStatusByID(context.Context, *GetClusterCustomStatusByIDRequest) (*ClusterCustomStatus, error)
	GetClusterCustomStatusByName(context.Context, *GetClusterCustomStatusByNameRequest) (*ClusterCustomStatus, error)
	DeleteClusterCustomStatus(context.Context, *DeleteClusterCustomStatusRequest) (*emptypb.Empty, error)
	IsClusterCustomStatusExisted(context.Context, *IsClusterCustomStatusExistedRequest) (*IsClusterCustomStatusExistedResponse, error)
	ListClusterCustomStatus(context.Context, *ListClusterCustomStatusRequest) (*ListClusterCustomStatusResponse, error)
}

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

func (UnimplementedClusterCustomStatusServiceServer) SetClusterCustomStatus(context.Context, *SetClusterCustomStatusRequest) (*ClusterCustomStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetClusterCustomStatus not implemented")
}
func (UnimplementedClusterCustomStatusServiceServer) GetClusterCustomStatusByID(context.Context, *GetClusterCustomStatusByIDRequest) (*ClusterCustomStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterCustomStatusByID not implemented")
}
func (UnimplementedClusterCustomStatusServiceServer) GetClusterCustomStatusByName(context.Context, *GetClusterCustomStatusByNameRequest) (*ClusterCustomStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterCustomStatusByName not implemented")
}
func (UnimplementedClusterCustomStatusServiceServer) DeleteClusterCustomStatus(context.Context, *DeleteClusterCustomStatusRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteClusterCustomStatus not implemented")
}
func (UnimplementedClusterCustomStatusServiceServer) IsClusterCustomStatusExisted(context.Context, *IsClusterCustomStatusExistedRequest) (*IsClusterCustomStatusExistedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsClusterCustomStatusExisted not implemented")
}
func (UnimplementedClusterCustomStatusServiceServer) ListClusterCustomStatus(context.Context, *ListClusterCustomStatusRequest) (*ListClusterCustomStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClusterCustomStatus not implemented")
}

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

func RegisterClusterCustomStatusServiceServer(s grpc.ServiceRegistrar, srv ClusterCustomStatusServiceServer) {
	s.RegisterService(&ClusterCustomStatusService_ServiceDesc, srv)
}

func _ClusterCustomStatusService_SetClusterCustomStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetClusterCustomStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterCustomStatusServiceServer).SetClusterCustomStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterCustomStatusService_SetClusterCustomStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterCustomStatusServiceServer).SetClusterCustomStatus(ctx, req.(*SetClusterCustomStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterCustomStatusService_GetClusterCustomStatusByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterCustomStatusByIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterCustomStatusServiceServer).GetClusterCustomStatusByID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterCustomStatusService_GetClusterCustomStatusByID_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterCustomStatusServiceServer).GetClusterCustomStatusByID(ctx, req.(*GetClusterCustomStatusByIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterCustomStatusService_GetClusterCustomStatusByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterCustomStatusByNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterCustomStatusServiceServer).GetClusterCustomStatusByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterCustomStatusService_GetClusterCustomStatusByName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterCustomStatusServiceServer).GetClusterCustomStatusByName(ctx, req.(*GetClusterCustomStatusByNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterCustomStatusService_DeleteClusterCustomStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteClusterCustomStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterCustomStatusServiceServer).DeleteClusterCustomStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterCustomStatusService_DeleteClusterCustomStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterCustomStatusServiceServer).DeleteClusterCustomStatus(ctx, req.(*DeleteClusterCustomStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterCustomStatusService_IsClusterCustomStatusExisted_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsClusterCustomStatusExistedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterCustomStatusServiceServer).IsClusterCustomStatusExisted(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterCustomStatusService_IsClusterCustomStatusExisted_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterCustomStatusServiceServer).IsClusterCustomStatusExisted(ctx, req.(*IsClusterCustomStatusExistedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ClusterCustomStatusService_ListClusterCustomStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListClusterCustomStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterCustomStatusServiceServer).ListClusterCustomStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ClusterCustomStatusService_ListClusterCustomStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterCustomStatusServiceServer).ListClusterCustomStatus(ctx, req.(*ListClusterCustomStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ClusterCustomStatusService_ServiceDesc is the grpc.ServiceDesc for ClusterCustomStatusService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ClusterCustomStatusService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "tidb_mgmt_service.v1.ClusterCustomStatusService",
	HandlerType: (*ClusterCustomStatusServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetClusterCustomStatus",
			Handler:    _ClusterCustomStatusService_SetClusterCustomStatus_Handler,
		},
		{
			MethodName: "GetClusterCustomStatusByID",
			Handler:    _ClusterCustomStatusService_GetClusterCustomStatusByID_Handler,
		},
		{
			MethodName: "GetClusterCustomStatusByName",
			Handler:    _ClusterCustomStatusService_GetClusterCustomStatusByName_Handler,
		},
		{
			MethodName: "DeleteClusterCustomStatus",
			Handler:    _ClusterCustomStatusService_DeleteClusterCustomStatus_Handler,
		},
		{
			MethodName: "IsClusterCustomStatusExisted",
			Handler:    _ClusterCustomStatusService_IsClusterCustomStatusExisted_Handler,
		},
		{
			MethodName: "ListClusterCustomStatus",
			Handler:    _ClusterCustomStatusService_ListClusterCustomStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/services.proto",
}

const (
	RegionService_RegisterCloudProvider_FullMethodName          = "/tidb_mgmt_service.v1.RegionService/RegisterCloudProvider"
	RegionService_ListCloudProviders_FullMethodName             = "/tidb_mgmt_service.v1.RegionService/ListCloudProviders"
	RegionService_RegisterRegion_FullMethodName                 = "/tidb_mgmt_service.v1.RegionService/RegisterRegion"
	RegionService_ListRegions_FullMethodName                    = "/tidb_mgmt_service.v1.RegionService/ListRegions"
	RegionService_GetRegion_FullMethodName                      = "/tidb_mgmt_service.v1.RegionService/GetRegion"
	RegionService_SelectRegionByOrganizationId_FullMethodName   = "/tidb_mgmt_service.v1.RegionService/SelectRegionByOrganizationId"
	RegionService_UpdateRegion_FullMethodName                   = "/tidb_mgmt_service.v1.RegionService/UpdateRegion"
	RegionService_CheckRegionStatus_FullMethodName              = "/tidb_mgmt_service.v1.RegionService/CheckRegionStatus"
	RegionService_DeleteRegion_FullMethodName                   = "/tidb_mgmt_service.v1.RegionService/DeleteRegion"
	RegionService_UpdateRegionOpsAuditLogSetting_FullMethodName = "/tidb_mgmt_service.v1.RegionService/UpdateRegionOpsAuditLogSetting"
	RegionService_RegisterRegionProviderIdentity_FullMethodName = "/tidb_mgmt_service.v1.RegionService/RegisterRegionProviderIdentity"
	RegionService_ListRegionProviderIdentities_FullMethodName   = "/tidb_mgmt_service.v1.RegionService/ListRegionProviderIdentities"
)

// 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 {
	RegisterCloudProvider(ctx context.Context, in *RegisterCloudProviderRequest, opts ...grpc.CallOption) (*CloudProvider, error)
	ListCloudProviders(ctx context.Context, in *ListCloudProvidersRequest, opts ...grpc.CallOption) (*ListCloudProvidersResponse, error)
	RegisterRegion(ctx context.Context, in *RegisterRegionRequest, opts ...grpc.CallOption) (*Region, error)
	ListRegions(ctx context.Context, in *ListRegionsRequest, opts ...grpc.CallOption) (*ListRegionsResponse, error)
	GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*Region, error)
	SelectRegionByOrganizationId(ctx context.Context, in *SelectRegionByOrganizationIdRequest, opts ...grpc.CallOption) (*Region, error)
	UpdateRegion(ctx context.Context, in *UpdateRegionRequest, opts ...grpc.CallOption) (*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)
	// only for byoc internal use
	UpdateRegionOpsAuditLogSetting(ctx context.Context, in *UpdateRegionOpsAuditLogSettingRequest, opts ...grpc.CallOption) (*v1.UpdateRegionOpsAuditLogSettingResponse, error)
	// only for nextgen(premium and byoc) internal use
	RegisterRegionProviderIdentity(ctx context.Context, in *RegisterRegionProviderIdentityRequest, opts ...grpc.CallOption) (*v1.RegionProviderIdentity, error)
	// only for nextgen(premium and byoc) internal use
	ListRegionProviderIdentities(ctx context.Context, in *ListRegionProviderIdentitiesRequest, opts ...grpc.CallOption) (*v1.ListRegionProviderIdentitiesResponse, error)
}

type regionServiceClient struct {
	cc grpc.ClientConnInterface
}

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

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

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) RegisterRegion(ctx context.Context, in *RegisterRegionRequest, opts ...grpc.CallOption) (*Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Region)
	err := c.cc.Invoke(ctx, RegionService_RegisterRegion_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) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Region)
	err := c.cc.Invoke(ctx, RegionService_GetRegion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) SelectRegionByOrganizationId(ctx context.Context, in *SelectRegionByOrganizationIdRequest, opts ...grpc.CallOption) (*Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Region)
	err := c.cc.Invoke(ctx, RegionService_SelectRegionByOrganizationId_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) (*Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(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
}

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

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

func (c *regionServiceClient) ListRegionProviderIdentities(ctx context.Context, in *ListRegionProviderIdentitiesRequest, opts ...grpc.CallOption) (*v1.ListRegionProviderIdentitiesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.ListRegionProviderIdentitiesResponse)
	err := c.cc.Invoke(ctx, RegionService_ListRegionProviderIdentities_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 {
	RegisterCloudProvider(context.Context, *RegisterCloudProviderRequest) (*CloudProvider, error)
	ListCloudProviders(context.Context, *ListCloudProvidersRequest) (*ListCloudProvidersResponse, error)
	RegisterRegion(context.Context, *RegisterRegionRequest) (*Region, error)
	ListRegions(context.Context, *ListRegionsRequest) (*ListRegionsResponse, error)
	GetRegion(context.Context, *GetRegionRequest) (*Region, error)
	SelectRegionByOrganizationId(context.Context, *SelectRegionByOrganizationIdRequest) (*Region, error)
	UpdateRegion(context.Context, *UpdateRegionRequest) (*Region, error)
	CheckRegionStatus(context.Context, *CheckRegionStatusRequest) (*emptypb.Empty, error)
	DeleteRegion(context.Context, *DeleteRegionRequest) (*emptypb.Empty, error)
	// only for byoc internal use
	UpdateRegionOpsAuditLogSetting(context.Context, *UpdateRegionOpsAuditLogSettingRequest) (*v1.UpdateRegionOpsAuditLogSettingResponse, error)
	// only for nextgen(premium and byoc) internal use
	RegisterRegionProviderIdentity(context.Context, *RegisterRegionProviderIdentityRequest) (*v1.RegionProviderIdentity, error)
	// only for nextgen(premium and byoc) internal use
	ListRegionProviderIdentities(context.Context, *ListRegionProviderIdentitiesRequest) (*v1.ListRegionProviderIdentitiesResponse, error)
}

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

func (UnimplementedRegionServiceServer) RegisterCloudProvider(context.Context, *RegisterCloudProviderRequest) (*CloudProvider, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterCloudProvider not implemented")
}
func (UnimplementedRegionServiceServer) ListCloudProviders(context.Context, *ListCloudProvidersRequest) (*ListCloudProvidersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCloudProviders not implemented")
}
func (UnimplementedRegionServiceServer) RegisterRegion(context.Context, *RegisterRegionRequest) (*Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterRegion not implemented")
}
func (UnimplementedRegionServiceServer) ListRegions(context.Context, *ListRegionsRequest) (*ListRegionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRegions not implemented")
}
func (UnimplementedRegionServiceServer) GetRegion(context.Context, *GetRegionRequest) (*Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRegion not implemented")
}
func (UnimplementedRegionServiceServer) SelectRegionByOrganizationId(context.Context, *SelectRegionByOrganizationIdRequest) (*Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SelectRegionByOrganizationId not implemented")
}
func (UnimplementedRegionServiceServer) UpdateRegion(context.Context, *UpdateRegionRequest) (*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")
}
func (UnimplementedRegionServiceServer) UpdateRegionOpsAuditLogSetting(context.Context, *UpdateRegionOpsAuditLogSettingRequest) (*v1.UpdateRegionOpsAuditLogSettingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRegionOpsAuditLogSetting not implemented")
}
func (UnimplementedRegionServiceServer) RegisterRegionProviderIdentity(context.Context, *RegisterRegionProviderIdentityRequest) (*v1.RegionProviderIdentity, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterRegionProviderIdentity not implemented")
}
func (UnimplementedRegionServiceServer) ListRegionProviderIdentities(context.Context, *ListRegionProviderIdentitiesRequest) (*v1.ListRegionProviderIdentitiesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRegionProviderIdentities 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_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_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_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_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_GetRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRegionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).GetRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_GetRegion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).GetRegion(ctx, req.(*GetRegionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_SelectRegionByOrganizationId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SelectRegionByOrganizationIdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).SelectRegionByOrganizationId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_SelectRegionByOrganizationId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).SelectRegionByOrganizationId(ctx, req.(*SelectRegionByOrganizationIdRequest))
	}
	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)
}

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

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

func _RegionService_ListRegionProviderIdentities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRegionProviderIdentitiesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).ListRegionProviderIdentities(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_ListRegionProviderIdentities_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).ListRegionProviderIdentities(ctx, req.(*ListRegionProviderIdentitiesRequest))
	}
	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: "tidb_mgmt_service.v1.RegionService",
	HandlerType: (*RegionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterCloudProvider",
			Handler:    _RegionService_RegisterCloudProvider_Handler,
		},
		{
			MethodName: "ListCloudProviders",
			Handler:    _RegionService_ListCloudProviders_Handler,
		},
		{
			MethodName: "RegisterRegion",
			Handler:    _RegionService_RegisterRegion_Handler,
		},
		{
			MethodName: "ListRegions",
			Handler:    _RegionService_ListRegions_Handler,
		},
		{
			MethodName: "GetRegion",
			Handler:    _RegionService_GetRegion_Handler,
		},
		{
			MethodName: "SelectRegionByOrganizationId",
			Handler:    _RegionService_SelectRegionByOrganizationId_Handler,
		},
		{
			MethodName: "UpdateRegion",
			Handler:    _RegionService_UpdateRegion_Handler,
		},
		{
			MethodName: "CheckRegionStatus",
			Handler:    _RegionService_CheckRegionStatus_Handler,
		},
		{
			MethodName: "DeleteRegion",
			Handler:    _RegionService_DeleteRegion_Handler,
		},
		{
			MethodName: "UpdateRegionOpsAuditLogSetting",
			Handler:    _RegionService_UpdateRegionOpsAuditLogSetting_Handler,
		},
		{
			MethodName: "RegisterRegionProviderIdentity",
			Handler:    _RegionService_RegisterRegionProviderIdentity_Handler,
		},
		{
			MethodName: "ListRegionProviderIdentities",
			Handler:    _RegionService_ListRegionProviderIdentities_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/services.proto",
}

const (
	VpcPeeringService_CreateVpcPeering_FullMethodName = "/tidb_mgmt_service.v1.VpcPeeringService/CreateVpcPeering"
	VpcPeeringService_ListVpcPeerings_FullMethodName  = "/tidb_mgmt_service.v1.VpcPeeringService/ListVpcPeerings"
	VpcPeeringService_GetVpcPeering_FullMethodName    = "/tidb_mgmt_service.v1.VpcPeeringService/GetVpcPeering"
	VpcPeeringService_DeleteVpcPeering_FullMethodName = "/tidb_mgmt_service.v1.VpcPeeringService/DeleteVpcPeering"
)

// VpcPeeringServiceClient is the client API for VpcPeeringService 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.
//
// only for internal use
// work with dedicated cluster service
type VpcPeeringServiceClient interface {
	CreateVpcPeering(ctx context.Context, in *CreateVpcPeeringRequest, opts ...grpc.CallOption) (*CreateVpcPeeringResponse, error)
	ListVpcPeerings(ctx context.Context, in *ListVpcPeeringsRequest, opts ...grpc.CallOption) (*ListVpcPeeringsResponse, error)
	GetVpcPeering(ctx context.Context, in *GetVpcPeeringRequest, opts ...grpc.CallOption) (*GetVpcPeeringResponse, error)
	DeleteVpcPeering(ctx context.Context, in *DeleteVpcPeeringRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type vpcPeeringServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewVpcPeeringServiceClient(cc grpc.ClientConnInterface) VpcPeeringServiceClient {
	return &vpcPeeringServiceClient{cc}
}

func (c *vpcPeeringServiceClient) 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, VpcPeeringService_CreateVpcPeering_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcPeeringServiceClient) 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, VpcPeeringService_ListVpcPeerings_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *vpcPeeringServiceClient) 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, VpcPeeringService_DeleteVpcPeering_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VpcPeeringServiceServer is the server API for VpcPeeringService service.
// All implementations should embed UnimplementedVpcPeeringServiceServer
// for forward compatibility
//
// only for internal use
// work with dedicated cluster service
type VpcPeeringServiceServer interface {
	CreateVpcPeering(context.Context, *CreateVpcPeeringRequest) (*CreateVpcPeeringResponse, error)
	ListVpcPeerings(context.Context, *ListVpcPeeringsRequest) (*ListVpcPeeringsResponse, error)
	GetVpcPeering(context.Context, *GetVpcPeeringRequest) (*GetVpcPeeringResponse, error)
	DeleteVpcPeering(context.Context, *DeleteVpcPeeringRequest) (*emptypb.Empty, error)
}

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

func (UnimplementedVpcPeeringServiceServer) CreateVpcPeering(context.Context, *CreateVpcPeeringRequest) (*CreateVpcPeeringResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateVpcPeering not implemented")
}
func (UnimplementedVpcPeeringServiceServer) ListVpcPeerings(context.Context, *ListVpcPeeringsRequest) (*ListVpcPeeringsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListVpcPeerings not implemented")
}
func (UnimplementedVpcPeeringServiceServer) GetVpcPeering(context.Context, *GetVpcPeeringRequest) (*GetVpcPeeringResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVpcPeering not implemented")
}
func (UnimplementedVpcPeeringServiceServer) DeleteVpcPeering(context.Context, *DeleteVpcPeeringRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteVpcPeering not implemented")
}

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

func RegisterVpcPeeringServiceServer(s grpc.ServiceRegistrar, srv VpcPeeringServiceServer) {
	s.RegisterService(&VpcPeeringService_ServiceDesc, srv)
}

func _VpcPeeringService_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.(VpcPeeringServiceServer).CreateVpcPeering(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcPeeringService_CreateVpcPeering_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcPeeringServiceServer).CreateVpcPeering(ctx, req.(*CreateVpcPeeringRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcPeeringService_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.(VpcPeeringServiceServer).ListVpcPeerings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcPeeringService_ListVpcPeerings_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcPeeringServiceServer).ListVpcPeerings(ctx, req.(*ListVpcPeeringsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcPeeringService_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.(VpcPeeringServiceServer).GetVpcPeering(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcPeeringService_GetVpcPeering_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcPeeringServiceServer).GetVpcPeering(ctx, req.(*GetVpcPeeringRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcPeeringService_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.(VpcPeeringServiceServer).DeleteVpcPeering(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: VpcPeeringService_DeleteVpcPeering_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcPeeringServiceServer).DeleteVpcPeering(ctx, req.(*DeleteVpcPeeringRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// VpcPeeringService_ServiceDesc is the grpc.ServiceDesc for VpcPeeringService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var VpcPeeringService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "tidb_mgmt_service.v1.VpcPeeringService",
	HandlerType: (*VpcPeeringServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateVpcPeering",
			Handler:    _VpcPeeringService_CreateVpcPeering_Handler,
		},
		{
			MethodName: "ListVpcPeerings",
			Handler:    _VpcPeeringService_ListVpcPeerings_Handler,
		},
		{
			MethodName: "GetVpcPeering",
			Handler:    _VpcPeeringService_GetVpcPeering_Handler,
		},
		{
			MethodName: "DeleteVpcPeering",
			Handler:    _VpcPeeringService_DeleteVpcPeering_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/services.proto",
}

const (
	DataPlaneService_GetCompatCluster_FullMethodName  = "/tidb_mgmt_service.v1.DataPlaneService/GetCompatCluster"
	DataPlaneService_GetCompatNetwork_FullMethodName  = "/tidb_mgmt_service.v1.DataPlaneService/GetCompatNetwork"
	DataPlaneService_GetCompatProvider_FullMethodName = "/tidb_mgmt_service.v1.DataPlaneService/GetCompatProvider"
)

// DataPlaneServiceClient is the client API for DataPlaneService 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 DataPlaneServiceClient interface {
	GetCompatCluster(ctx context.Context, in *GetCompatClusterRequest, opts ...grpc.CallOption) (*v11.CompatCluster, error)
	GetCompatNetwork(ctx context.Context, in *GetCompatNetworkRequest, opts ...grpc.CallOption) (*v11.CompatNetwork, error)
	GetCompatProvider(ctx context.Context, in *GetCompatProviderRequest, opts ...grpc.CallOption) (*v11.CompatProvider, error)
}

type dataPlaneServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDataPlaneServiceClient(cc grpc.ClientConnInterface) DataPlaneServiceClient {
	return &dataPlaneServiceClient{cc}
}

func (c *dataPlaneServiceClient) GetCompatCluster(ctx context.Context, in *GetCompatClusterRequest, opts ...grpc.CallOption) (*v11.CompatCluster, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.CompatCluster)
	err := c.cc.Invoke(ctx, DataPlaneService_GetCompatCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataPlaneServiceClient) GetCompatNetwork(ctx context.Context, in *GetCompatNetworkRequest, opts ...grpc.CallOption) (*v11.CompatNetwork, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.CompatNetwork)
	err := c.cc.Invoke(ctx, DataPlaneService_GetCompatNetwork_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataPlaneServiceClient) GetCompatProvider(ctx context.Context, in *GetCompatProviderRequest, opts ...grpc.CallOption) (*v11.CompatProvider, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.CompatProvider)
	err := c.cc.Invoke(ctx, DataPlaneService_GetCompatProvider_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DataPlaneServiceServer is the server API for DataPlaneService service.
// All implementations should embed UnimplementedDataPlaneServiceServer
// for forward compatibility
type DataPlaneServiceServer interface {
	GetCompatCluster(context.Context, *GetCompatClusterRequest) (*v11.CompatCluster, error)
	GetCompatNetwork(context.Context, *GetCompatNetworkRequest) (*v11.CompatNetwork, error)
	GetCompatProvider(context.Context, *GetCompatProviderRequest) (*v11.CompatProvider, error)
}

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

func (UnimplementedDataPlaneServiceServer) GetCompatCluster(context.Context, *GetCompatClusterRequest) (*v11.CompatCluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCompatCluster not implemented")
}
func (UnimplementedDataPlaneServiceServer) GetCompatNetwork(context.Context, *GetCompatNetworkRequest) (*v11.CompatNetwork, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCompatNetwork not implemented")
}
func (UnimplementedDataPlaneServiceServer) GetCompatProvider(context.Context, *GetCompatProviderRequest) (*v11.CompatProvider, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCompatProvider not implemented")
}

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

func RegisterDataPlaneServiceServer(s grpc.ServiceRegistrar, srv DataPlaneServiceServer) {
	s.RegisterService(&DataPlaneService_ServiceDesc, srv)
}

func _DataPlaneService_GetCompatCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCompatClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataPlaneServiceServer).GetCompatCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DataPlaneService_GetCompatCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataPlaneServiceServer).GetCompatCluster(ctx, req.(*GetCompatClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataPlaneService_GetCompatNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCompatNetworkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataPlaneServiceServer).GetCompatNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DataPlaneService_GetCompatNetwork_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataPlaneServiceServer).GetCompatNetwork(ctx, req.(*GetCompatNetworkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataPlaneService_GetCompatProvider_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCompatProviderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataPlaneServiceServer).GetCompatProvider(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DataPlaneService_GetCompatProvider_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataPlaneServiceServer).GetCompatProvider(ctx, req.(*GetCompatProviderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DataPlaneService_ServiceDesc is the grpc.ServiceDesc for DataPlaneService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DataPlaneService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "tidb_mgmt_service.v1.DataPlaneService",
	HandlerType: (*DataPlaneServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCompatCluster",
			Handler:    _DataPlaneService_GetCompatCluster_Handler,
		},
		{
			MethodName: "GetCompatNetwork",
			Handler:    _DataPlaneService_GetCompatNetwork_Handler,
		},
		{
			MethodName: "GetCompatProvider",
			Handler:    _DataPlaneService_GetCompatProvider_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/services.proto",
}

const (
	OrganizationConfigService_UpdateOrganizationDefaultRuVersion_FullMethodName = "/tidb_mgmt_service.v1.OrganizationConfigService/UpdateOrganizationDefaultRuVersion"
	OrganizationConfigService_GetOrganizationDefaultRuVersion_FullMethodName    = "/tidb_mgmt_service.v1.OrganizationConfigService/GetOrganizationDefaultRuVersion"
)

// OrganizationConfigServiceClient is the client API for OrganizationConfigService 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.
//
// OrganizationConfigService manages organization-level configurations.
// Internal ops only.
type OrganizationConfigServiceClient interface {
	// Set default ru_version for an organization. Affects future cluster creation only.
	UpdateOrganizationDefaultRuVersion(ctx context.Context, in *UpdateOrganizationDefaultRuVersionRequest, opts ...grpc.CallOption) (*OrganizationRuConfig, error)
	// Get default ru_version for an organization.
	GetOrganizationDefaultRuVersion(ctx context.Context, in *GetOrganizationDefaultRuVersionRequest, opts ...grpc.CallOption) (*OrganizationRuConfig, error)
}

type organizationConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewOrganizationConfigServiceClient(cc grpc.ClientConnInterface) OrganizationConfigServiceClient {
	return &organizationConfigServiceClient{cc}
}

func (c *organizationConfigServiceClient) UpdateOrganizationDefaultRuVersion(ctx context.Context, in *UpdateOrganizationDefaultRuVersionRequest, opts ...grpc.CallOption) (*OrganizationRuConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OrganizationRuConfig)
	err := c.cc.Invoke(ctx, OrganizationConfigService_UpdateOrganizationDefaultRuVersion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *organizationConfigServiceClient) GetOrganizationDefaultRuVersion(ctx context.Context, in *GetOrganizationDefaultRuVersionRequest, opts ...grpc.CallOption) (*OrganizationRuConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OrganizationRuConfig)
	err := c.cc.Invoke(ctx, OrganizationConfigService_GetOrganizationDefaultRuVersion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// OrganizationConfigServiceServer is the server API for OrganizationConfigService service.
// All implementations should embed UnimplementedOrganizationConfigServiceServer
// for forward compatibility
//
// OrganizationConfigService manages organization-level configurations.
// Internal ops only.
type OrganizationConfigServiceServer interface {
	// Set default ru_version for an organization. Affects future cluster creation only.
	UpdateOrganizationDefaultRuVersion(context.Context, *UpdateOrganizationDefaultRuVersionRequest) (*OrganizationRuConfig, error)
	// Get default ru_version for an organization.
	GetOrganizationDefaultRuVersion(context.Context, *GetOrganizationDefaultRuVersionRequest) (*OrganizationRuConfig, error)
}

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

func (UnimplementedOrganizationConfigServiceServer) UpdateOrganizationDefaultRuVersion(context.Context, *UpdateOrganizationDefaultRuVersionRequest) (*OrganizationRuConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateOrganizationDefaultRuVersion not implemented")
}
func (UnimplementedOrganizationConfigServiceServer) GetOrganizationDefaultRuVersion(context.Context, *GetOrganizationDefaultRuVersionRequest) (*OrganizationRuConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrganizationDefaultRuVersion not implemented")
}

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

func RegisterOrganizationConfigServiceServer(s grpc.ServiceRegistrar, srv OrganizationConfigServiceServer) {
	s.RegisterService(&OrganizationConfigService_ServiceDesc, srv)
}

func _OrganizationConfigService_UpdateOrganizationDefaultRuVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateOrganizationDefaultRuVersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OrganizationConfigServiceServer).UpdateOrganizationDefaultRuVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OrganizationConfigService_UpdateOrganizationDefaultRuVersion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OrganizationConfigServiceServer).UpdateOrganizationDefaultRuVersion(ctx, req.(*UpdateOrganizationDefaultRuVersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OrganizationConfigService_GetOrganizationDefaultRuVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrganizationDefaultRuVersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OrganizationConfigServiceServer).GetOrganizationDefaultRuVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OrganizationConfigService_GetOrganizationDefaultRuVersion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OrganizationConfigServiceServer).GetOrganizationDefaultRuVersion(ctx, req.(*GetOrganizationDefaultRuVersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// OrganizationConfigService_ServiceDesc is the grpc.ServiceDesc for OrganizationConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var OrganizationConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "tidb_mgmt_service.v1.OrganizationConfigService",
	HandlerType: (*OrganizationConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UpdateOrganizationDefaultRuVersion",
			Handler:    _OrganizationConfigService_UpdateOrganizationDefaultRuVersion_Handler,
		},
		{
			MethodName: "GetOrganizationDefaultRuVersion",
			Handler:    _OrganizationConfigService_GetOrganizationDefaultRuVersion_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/services.proto",
}