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

package cluster_managementv1beta2

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// 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 (
	TiDBService_ListTidbs_FullMethodName                   = "/bff.cluster_management.v1beta2.TiDBService/ListTidbs"
	TiDBService_GetTidb_FullMethodName                     = "/bff.cluster_management.v1beta2.TiDBService/GetTidb"
	TiDBService_GetClusterInventory_FullMethodName         = "/bff.cluster_management.v1beta2.TiDBService/GetClusterInventory"
	TiDBService_BindTags_FullMethodName                    = "/bff.cluster_management.v1beta2.TiDBService/BindTags"
	TiDBService_UnbindTags_FullMethodName                  = "/bff.cluster_management.v1beta2.TiDBService/UnbindTags"
	TiDBService_MoveTiDB_FullMethodName                    = "/bff.cluster_management.v1beta2.TiDBService/MoveTiDB"
	TiDBService_BatchMoveTiDBs_FullMethodName              = "/bff.cluster_management.v1beta2.TiDBService/BatchMoveTiDBs"
	TiDBService_GetProjectMigrationTask_FullMethodName     = "/bff.cluster_management.v1beta2.TiDBService/GetProjectMigrationTask"
	TiDBService_ApproveProjectMigrationTask_FullMethodName = "/bff.cluster_management.v1beta2.TiDBService/ApproveProjectMigrationTask"
)

// TiDBServiceClient is the client API for TiDBService 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 TiDBServiceClient interface {
	ListTidbs(ctx context.Context, in *ListTidbsRequest, opts ...grpc.CallOption) (*ListTidbsResponse, error)
	GetTidb(ctx context.Context, in *GetTidbRequest, opts ...grpc.CallOption) (*Tidb, error)
	GetClusterInventory(ctx context.Context, in *GetClusterInventoryRequest, opts ...grpc.CallOption) (*GetClusterInventoryResponse, error)
	BindTags(ctx context.Context, in *BindTagsRequest, opts ...grpc.CallOption) (*BindTagsResponse, error)
	UnbindTags(ctx context.Context, in *UnbindTagsRequest, opts ...grpc.CallOption) (*UnbindTagsResponse, error)
	MoveTiDB(ctx context.Context, in *MoveTiDBRequest, opts ...grpc.CallOption) (*MoveTiDBResponse, error)
	BatchMoveTiDBs(ctx context.Context, in *BatchMoveTiDBsRequest, opts ...grpc.CallOption) (*BatchMoveTiDBsResponse, error)
	GetProjectMigrationTask(ctx context.Context, in *GetProjectMigrationTaskRequest, opts ...grpc.CallOption) (*ProjectMigrationTask, error)
	ApproveProjectMigrationTask(ctx context.Context, in *ApproveProjectMigrationTaskRequest, opts ...grpc.CallOption) (*ApproveProjectMigrationTaskResponse, error)
}

type tiDBServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTiDBServiceClient(cc grpc.ClientConnInterface) TiDBServiceClient {
	return &tiDBServiceClient{cc}
}

func (c *tiDBServiceClient) ListTidbs(ctx context.Context, in *ListTidbsRequest, opts ...grpc.CallOption) (*ListTidbsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTidbsResponse)
	err := c.cc.Invoke(ctx, TiDBService_ListTidbs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) GetTidb(ctx context.Context, in *GetTidbRequest, opts ...grpc.CallOption) (*Tidb, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Tidb)
	err := c.cc.Invoke(ctx, TiDBService_GetTidb_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) GetClusterInventory(ctx context.Context, in *GetClusterInventoryRequest, opts ...grpc.CallOption) (*GetClusterInventoryResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetClusterInventoryResponse)
	err := c.cc.Invoke(ctx, TiDBService_GetClusterInventory_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) BindTags(ctx context.Context, in *BindTagsRequest, opts ...grpc.CallOption) (*BindTagsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BindTagsResponse)
	err := c.cc.Invoke(ctx, TiDBService_BindTags_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) UnbindTags(ctx context.Context, in *UnbindTagsRequest, opts ...grpc.CallOption) (*UnbindTagsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UnbindTagsResponse)
	err := c.cc.Invoke(ctx, TiDBService_UnbindTags_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) MoveTiDB(ctx context.Context, in *MoveTiDBRequest, opts ...grpc.CallOption) (*MoveTiDBResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MoveTiDBResponse)
	err := c.cc.Invoke(ctx, TiDBService_MoveTiDB_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) BatchMoveTiDBs(ctx context.Context, in *BatchMoveTiDBsRequest, opts ...grpc.CallOption) (*BatchMoveTiDBsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchMoveTiDBsResponse)
	err := c.cc.Invoke(ctx, TiDBService_BatchMoveTiDBs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) GetProjectMigrationTask(ctx context.Context, in *GetProjectMigrationTaskRequest, opts ...grpc.CallOption) (*ProjectMigrationTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ProjectMigrationTask)
	err := c.cc.Invoke(ctx, TiDBService_GetProjectMigrationTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tiDBServiceClient) ApproveProjectMigrationTask(ctx context.Context, in *ApproveProjectMigrationTaskRequest, opts ...grpc.CallOption) (*ApproveProjectMigrationTaskResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ApproveProjectMigrationTaskResponse)
	err := c.cc.Invoke(ctx, TiDBService_ApproveProjectMigrationTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TiDBServiceServer is the server API for TiDBService service.
// All implementations should embed UnimplementedTiDBServiceServer
// for forward compatibility
type TiDBServiceServer interface {
	ListTidbs(context.Context, *ListTidbsRequest) (*ListTidbsResponse, error)
	GetTidb(context.Context, *GetTidbRequest) (*Tidb, error)
	GetClusterInventory(context.Context, *GetClusterInventoryRequest) (*GetClusterInventoryResponse, error)
	BindTags(context.Context, *BindTagsRequest) (*BindTagsResponse, error)
	UnbindTags(context.Context, *UnbindTagsRequest) (*UnbindTagsResponse, error)
	MoveTiDB(context.Context, *MoveTiDBRequest) (*MoveTiDBResponse, error)
	BatchMoveTiDBs(context.Context, *BatchMoveTiDBsRequest) (*BatchMoveTiDBsResponse, error)
	GetProjectMigrationTask(context.Context, *GetProjectMigrationTaskRequest) (*ProjectMigrationTask, error)
	ApproveProjectMigrationTask(context.Context, *ApproveProjectMigrationTaskRequest) (*ApproveProjectMigrationTaskResponse, error)
}

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

func (UnimplementedTiDBServiceServer) ListTidbs(context.Context, *ListTidbsRequest) (*ListTidbsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTidbs not implemented")
}
func (UnimplementedTiDBServiceServer) GetTidb(context.Context, *GetTidbRequest) (*Tidb, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTidb not implemented")
}
func (UnimplementedTiDBServiceServer) GetClusterInventory(context.Context, *GetClusterInventoryRequest) (*GetClusterInventoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterInventory not implemented")
}
func (UnimplementedTiDBServiceServer) BindTags(context.Context, *BindTagsRequest) (*BindTagsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BindTags not implemented")
}
func (UnimplementedTiDBServiceServer) UnbindTags(context.Context, *UnbindTagsRequest) (*UnbindTagsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnbindTags not implemented")
}
func (UnimplementedTiDBServiceServer) MoveTiDB(context.Context, *MoveTiDBRequest) (*MoveTiDBResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MoveTiDB not implemented")
}
func (UnimplementedTiDBServiceServer) BatchMoveTiDBs(context.Context, *BatchMoveTiDBsRequest) (*BatchMoveTiDBsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchMoveTiDBs not implemented")
}
func (UnimplementedTiDBServiceServer) GetProjectMigrationTask(context.Context, *GetProjectMigrationTaskRequest) (*ProjectMigrationTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProjectMigrationTask not implemented")
}
func (UnimplementedTiDBServiceServer) ApproveProjectMigrationTask(context.Context, *ApproveProjectMigrationTaskRequest) (*ApproveProjectMigrationTaskResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApproveProjectMigrationTask not implemented")
}

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

func RegisterTiDBServiceServer(s grpc.ServiceRegistrar, srv TiDBServiceServer) {
	s.RegisterService(&TiDBService_ServiceDesc, srv)
}

func _TiDBService_ListTidbs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTidbsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).ListTidbs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_ListTidbs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).ListTidbs(ctx, req.(*ListTidbsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_GetTidb_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTidbRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).GetTidb(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_GetTidb_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).GetTidb(ctx, req.(*GetTidbRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_GetClusterInventory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterInventoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).GetClusterInventory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_GetClusterInventory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).GetClusterInventory(ctx, req.(*GetClusterInventoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_BindTags_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BindTagsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).BindTags(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_BindTags_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).BindTags(ctx, req.(*BindTagsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_UnbindTags_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnbindTagsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).UnbindTags(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_UnbindTags_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).UnbindTags(ctx, req.(*UnbindTagsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_MoveTiDB_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MoveTiDBRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).MoveTiDB(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_MoveTiDB_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).MoveTiDB(ctx, req.(*MoveTiDBRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_BatchMoveTiDBs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchMoveTiDBsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).BatchMoveTiDBs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_BatchMoveTiDBs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).BatchMoveTiDBs(ctx, req.(*BatchMoveTiDBsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_GetProjectMigrationTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProjectMigrationTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).GetProjectMigrationTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_GetProjectMigrationTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).GetProjectMigrationTask(ctx, req.(*GetProjectMigrationTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TiDBService_ApproveProjectMigrationTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApproveProjectMigrationTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TiDBServiceServer).ApproveProjectMigrationTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TiDBService_ApproveProjectMigrationTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TiDBServiceServer).ApproveProjectMigrationTask(ctx, req.(*ApproveProjectMigrationTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TiDBService_ServiceDesc is the grpc.ServiceDesc for TiDBService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TiDBService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "bff.cluster_management.v1beta2.TiDBService",
	HandlerType: (*TiDBServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListTidbs",
			Handler:    _TiDBService_ListTidbs_Handler,
		},
		{
			MethodName: "GetTidb",
			Handler:    _TiDBService_GetTidb_Handler,
		},
		{
			MethodName: "GetClusterInventory",
			Handler:    _TiDBService_GetClusterInventory_Handler,
		},
		{
			MethodName: "BindTags",
			Handler:    _TiDBService_BindTags_Handler,
		},
		{
			MethodName: "UnbindTags",
			Handler:    _TiDBService_UnbindTags_Handler,
		},
		{
			MethodName: "MoveTiDB",
			Handler:    _TiDBService_MoveTiDB_Handler,
		},
		{
			MethodName: "BatchMoveTiDBs",
			Handler:    _TiDBService_BatchMoveTiDBs_Handler,
		},
		{
			MethodName: "GetProjectMigrationTask",
			Handler:    _TiDBService_GetProjectMigrationTask_Handler,
		},
		{
			MethodName: "ApproveProjectMigrationTask",
			Handler:    _TiDBService_ApproveProjectMigrationTask_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "bff/cluster_management/v1beta2/services.proto",
}

const (
	RegionService_ListRegions_FullMethodName        = "/bff.cluster_management.v1beta2.RegionService/ListRegions"
	RegionService_ListCloudProviders_FullMethodName = "/bff.cluster_management.v1beta2.RegionService/ListCloudProviders"
)

// 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 {
	ListRegions(ctx context.Context, in *ListRegionsRequest, opts ...grpc.CallOption) (*ListRegionsResponse, error)
	ListCloudProviders(ctx context.Context, in *ListCloudProvidersRequest, opts ...grpc.CallOption) (*ListCloudProvidersResponse, error)
}

type regionServiceClient struct {
	cc grpc.ClientConnInterface
}

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

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) 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
}

// RegionServiceServer is the server API for RegionService service.
// All implementations should embed UnimplementedRegionServiceServer
// for forward compatibility
type RegionServiceServer interface {
	ListRegions(context.Context, *ListRegionsRequest) (*ListRegionsResponse, error)
	ListCloudProviders(context.Context, *ListCloudProvidersRequest) (*ListCloudProvidersResponse, error)
}

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

func (UnimplementedRegionServiceServer) ListRegions(context.Context, *ListRegionsRequest) (*ListRegionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRegions not implemented")
}
func (UnimplementedRegionServiceServer) ListCloudProviders(context.Context, *ListCloudProvidersRequest) (*ListCloudProvidersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCloudProviders 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_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_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)
}

// 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: "bff.cluster_management.v1beta2.RegionService",
	HandlerType: (*RegionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListRegions",
			Handler:    _RegionService_ListRegions_Handler,
		},
		{
			MethodName: "ListCloudProviders",
			Handler:    _RegionService_ListCloudProviders_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "bff/cluster_management/v1beta2/services.proto",
}