// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.19.4
// source: pcmCore.proto

package pcmCore

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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	PcmCore_SyncInfo_FullMethodName = "/pcmCore.pcmCore/SyncInfo"
	PcmCore_InfoList_FullMethodName = "/pcmCore.pcmCore/InfoList"
)

// PcmCoreClient is the client API for PcmCore 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 PcmCoreClient interface {
	// SyncInfo Synchronous data information
	SyncInfo(ctx context.Context, in *SyncInfoReq, opts ...grpc.CallOption) (*SyncInfoResp, error)
	// InfoList
	InfoList(ctx context.Context, in *InfoListReq, opts ...grpc.CallOption) (*InfoListResp, error)
}

type pcmCoreClient struct {
	cc grpc.ClientConnInterface
}

func NewPcmCoreClient(cc grpc.ClientConnInterface) PcmCoreClient {
	return &pcmCoreClient{cc}
}

func (c *pcmCoreClient) SyncInfo(ctx context.Context, in *SyncInfoReq, opts ...grpc.CallOption) (*SyncInfoResp, error) {
	out := new(SyncInfoResp)
	err := c.cc.Invoke(ctx, PcmCore_SyncInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pcmCoreClient) InfoList(ctx context.Context, in *InfoListReq, opts ...grpc.CallOption) (*InfoListResp, error) {
	out := new(InfoListResp)
	err := c.cc.Invoke(ctx, PcmCore_InfoList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PcmCoreServer is the server API for PcmCore service.
// All implementations must embed UnimplementedPcmCoreServer
// for forward compatibility
type PcmCoreServer interface {
	// SyncInfo Synchronous data information
	SyncInfo(context.Context, *SyncInfoReq) (*SyncInfoResp, error)
	// InfoList
	InfoList(context.Context, *InfoListReq) (*InfoListResp, error)
	mustEmbedUnimplementedPcmCoreServer()
}

// UnimplementedPcmCoreServer must be embedded to have forward compatible implementations.
type UnimplementedPcmCoreServer struct {
}

func (UnimplementedPcmCoreServer) SyncInfo(context.Context, *SyncInfoReq) (*SyncInfoResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncInfo not implemented")
}
func (UnimplementedPcmCoreServer) InfoList(context.Context, *InfoListReq) (*InfoListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InfoList not implemented")
}
func (UnimplementedPcmCoreServer) mustEmbedUnimplementedPcmCoreServer() {}

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

func RegisterPcmCoreServer(s grpc.ServiceRegistrar, srv PcmCoreServer) {
	s.RegisterService(&PcmCore_ServiceDesc, srv)
}

func _PcmCore_SyncInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PcmCoreServer).SyncInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PcmCore_SyncInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PcmCoreServer).SyncInfo(ctx, req.(*SyncInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _PcmCore_InfoList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InfoListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PcmCoreServer).InfoList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PcmCore_InfoList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PcmCoreServer).InfoList(ctx, req.(*InfoListReq))
	}
	return interceptor(ctx, in, info, handler)
}

// PcmCore_ServiceDesc is the grpc.ServiceDesc for PcmCore service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PcmCore_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "pcmCore.pcmCore",
	HandlerType: (*PcmCoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SyncInfo",
			Handler:    _PcmCore_SyncInfo_Handler,
		},
		{
			MethodName: "InfoList",
			Handler:    _PcmCore_InfoList_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pcmCore.proto",
}

const (
	ParticipantService_RegisterParticipant_FullMethodName = "/pcmCore.participantService/registerParticipant"
	ParticipantService_ReportHeartbeat_FullMethodName     = "/pcmCore.participantService/reportHeartbeat"
	ParticipantService_ReportAvailable_FullMethodName     = "/pcmCore.participantService/reportAvailable"
	ParticipantService_ListParticipant_FullMethodName     = "/pcmCore.participantService/listParticipant"
	ParticipantService_ListPhyAvailable_FullMethodName    = "/pcmCore.participantService/listPhyAvailable"
	ParticipantService_ListPhyInformation_FullMethodName  = "/pcmCore.participantService/listPhyInformation"
	ParticipantService_RegisterTenant_FullMethodName      = "/pcmCore.participantService/registerTenant"
	ParticipantService_ListTenant_FullMethodName          = "/pcmCore.participantService/listTenant"
	ParticipantService_ApplyList_FullMethodName           = "/pcmCore.participantService/applyList"
	ParticipantService_DeleteList_FullMethodName          = "/pcmCore.participantService/deleteList"
	ParticipantService_RestartList_FullMethodName         = "/pcmCore.participantService/restartList"
	ParticipantService_PauseList_FullMethodName           = "/pcmCore.participantService/pauseList"
	ParticipantService_StartList_FullMethodName           = "/pcmCore.participantService/startList"
)

// ParticipantServiceClient is the client API for ParticipantService 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 ParticipantServiceClient interface {
	// registerParticipant Participant注册接口
	RegisterParticipant(ctx context.Context, in *ParticipantPhyReq, opts ...grpc.CallOption) (*ParticipantPhyResp, error)
	// reportHeartbeat 心跳请求
	ReportHeartbeat(ctx context.Context, in *ParticipantHeartbeatReq, opts ...grpc.CallOption) (*HealthCheckResp, error)
	// reportAvailable 监控数据上报
	ReportAvailable(ctx context.Context, in *ParticipantAvailReq, opts ...grpc.CallOption) (*ParticipantResp, error)
	// listParticipant 服务列表
	ListParticipant(ctx context.Context, in *ParticipantTenant, opts ...grpc.CallOption) (*ParticipantServiceResp, error)
	// listAvailable 集群动态信息列表
	ListPhyAvailable(ctx context.Context, in *ParticipantTenant, opts ...grpc.CallOption) (*ListParticipantAvailResp, error)
	// listPhyInformation 集群静态信息列表
	ListPhyInformation(ctx context.Context, in *ParticipantTenant, opts ...grpc.CallOption) (*ListParticipantPhyResp, error)
	// registerTenant 注册租户信息
	RegisterTenant(ctx context.Context, in *TenantInfo, opts ...grpc.CallOption) (*TenantResp, error)
	// listTenant 租户列表信息
	ListTenant(ctx context.Context, in *TenantInfo, opts ...grpc.CallOption) (*ListTenantResp, error)
	// applyList 执行任务列表
	ApplyList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error)
	// DeleteList 删除任务列表
	DeleteList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error)
	// RestartList 重启任务列表
	RestartList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error)
	// PauseList 暂停任务列表
	PauseList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error)
	// StartList 启动任务列表
	StartList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error)
}

type participantServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewParticipantServiceClient(cc grpc.ClientConnInterface) ParticipantServiceClient {
	return &participantServiceClient{cc}
}

func (c *participantServiceClient) RegisterParticipant(ctx context.Context, in *ParticipantPhyReq, opts ...grpc.CallOption) (*ParticipantPhyResp, error) {
	out := new(ParticipantPhyResp)
	err := c.cc.Invoke(ctx, ParticipantService_RegisterParticipant_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ReportHeartbeat(ctx context.Context, in *ParticipantHeartbeatReq, opts ...grpc.CallOption) (*HealthCheckResp, error) {
	out := new(HealthCheckResp)
	err := c.cc.Invoke(ctx, ParticipantService_ReportHeartbeat_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ReportAvailable(ctx context.Context, in *ParticipantAvailReq, opts ...grpc.CallOption) (*ParticipantResp, error) {
	out := new(ParticipantResp)
	err := c.cc.Invoke(ctx, ParticipantService_ReportAvailable_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ListParticipant(ctx context.Context, in *ParticipantTenant, opts ...grpc.CallOption) (*ParticipantServiceResp, error) {
	out := new(ParticipantServiceResp)
	err := c.cc.Invoke(ctx, ParticipantService_ListParticipant_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ListPhyAvailable(ctx context.Context, in *ParticipantTenant, opts ...grpc.CallOption) (*ListParticipantAvailResp, error) {
	out := new(ListParticipantAvailResp)
	err := c.cc.Invoke(ctx, ParticipantService_ListPhyAvailable_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ListPhyInformation(ctx context.Context, in *ParticipantTenant, opts ...grpc.CallOption) (*ListParticipantPhyResp, error) {
	out := new(ListParticipantPhyResp)
	err := c.cc.Invoke(ctx, ParticipantService_ListPhyInformation_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) RegisterTenant(ctx context.Context, in *TenantInfo, opts ...grpc.CallOption) (*TenantResp, error) {
	out := new(TenantResp)
	err := c.cc.Invoke(ctx, ParticipantService_RegisterTenant_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ListTenant(ctx context.Context, in *TenantInfo, opts ...grpc.CallOption) (*ListTenantResp, error) {
	out := new(ListTenantResp)
	err := c.cc.Invoke(ctx, ParticipantService_ListTenant_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) ApplyList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error) {
	out := new(ApplyListResp)
	err := c.cc.Invoke(ctx, ParticipantService_ApplyList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) DeleteList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error) {
	out := new(ApplyListResp)
	err := c.cc.Invoke(ctx, ParticipantService_DeleteList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) RestartList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error) {
	out := new(ApplyListResp)
	err := c.cc.Invoke(ctx, ParticipantService_RestartList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) PauseList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error) {
	out := new(ApplyListResp)
	err := c.cc.Invoke(ctx, ParticipantService_PauseList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *participantServiceClient) StartList(ctx context.Context, in *ApplyListReq, opts ...grpc.CallOption) (*ApplyListResp, error) {
	out := new(ApplyListResp)
	err := c.cc.Invoke(ctx, ParticipantService_StartList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ParticipantServiceServer is the server API for ParticipantService service.
// All implementations must embed UnimplementedParticipantServiceServer
// for forward compatibility
type ParticipantServiceServer interface {
	// registerParticipant Participant注册接口
	RegisterParticipant(context.Context, *ParticipantPhyReq) (*ParticipantPhyResp, error)
	// reportHeartbeat 心跳请求
	ReportHeartbeat(context.Context, *ParticipantHeartbeatReq) (*HealthCheckResp, error)
	// reportAvailable 监控数据上报
	ReportAvailable(context.Context, *ParticipantAvailReq) (*ParticipantResp, error)
	// listParticipant 服务列表
	ListParticipant(context.Context, *ParticipantTenant) (*ParticipantServiceResp, error)
	// listAvailable 集群动态信息列表
	ListPhyAvailable(context.Context, *ParticipantTenant) (*ListParticipantAvailResp, error)
	// listPhyInformation 集群静态信息列表
	ListPhyInformation(context.Context, *ParticipantTenant) (*ListParticipantPhyResp, error)
	// registerTenant 注册租户信息
	RegisterTenant(context.Context, *TenantInfo) (*TenantResp, error)
	// listTenant 租户列表信息
	ListTenant(context.Context, *TenantInfo) (*ListTenantResp, error)
	// applyList 执行任务列表
	ApplyList(context.Context, *ApplyListReq) (*ApplyListResp, error)
	// DeleteList 删除任务列表
	DeleteList(context.Context, *ApplyListReq) (*ApplyListResp, error)
	// RestartList 重启任务列表
	RestartList(context.Context, *ApplyListReq) (*ApplyListResp, error)
	// PauseList 暂停任务列表
	PauseList(context.Context, *ApplyListReq) (*ApplyListResp, error)
	// StartList 启动任务列表
	StartList(context.Context, *ApplyListReq) (*ApplyListResp, error)
	mustEmbedUnimplementedParticipantServiceServer()
}

// UnimplementedParticipantServiceServer must be embedded to have forward compatible implementations.
type UnimplementedParticipantServiceServer struct {
}

func (UnimplementedParticipantServiceServer) RegisterParticipant(context.Context, *ParticipantPhyReq) (*ParticipantPhyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterParticipant not implemented")
}
func (UnimplementedParticipantServiceServer) ReportHeartbeat(context.Context, *ParticipantHeartbeatReq) (*HealthCheckResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReportHeartbeat not implemented")
}
func (UnimplementedParticipantServiceServer) ReportAvailable(context.Context, *ParticipantAvailReq) (*ParticipantResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReportAvailable not implemented")
}
func (UnimplementedParticipantServiceServer) ListParticipant(context.Context, *ParticipantTenant) (*ParticipantServiceResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListParticipant not implemented")
}
func (UnimplementedParticipantServiceServer) ListPhyAvailable(context.Context, *ParticipantTenant) (*ListParticipantAvailResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPhyAvailable not implemented")
}
func (UnimplementedParticipantServiceServer) ListPhyInformation(context.Context, *ParticipantTenant) (*ListParticipantPhyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPhyInformation not implemented")
}
func (UnimplementedParticipantServiceServer) RegisterTenant(context.Context, *TenantInfo) (*TenantResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterTenant not implemented")
}
func (UnimplementedParticipantServiceServer) ListTenant(context.Context, *TenantInfo) (*ListTenantResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTenant not implemented")
}
func (UnimplementedParticipantServiceServer) ApplyList(context.Context, *ApplyListReq) (*ApplyListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyList not implemented")
}
func (UnimplementedParticipantServiceServer) DeleteList(context.Context, *ApplyListReq) (*ApplyListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteList not implemented")
}
func (UnimplementedParticipantServiceServer) RestartList(context.Context, *ApplyListReq) (*ApplyListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartList not implemented")
}
func (UnimplementedParticipantServiceServer) PauseList(context.Context, *ApplyListReq) (*ApplyListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseList not implemented")
}
func (UnimplementedParticipantServiceServer) StartList(context.Context, *ApplyListReq) (*ApplyListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartList not implemented")
}
func (UnimplementedParticipantServiceServer) mustEmbedUnimplementedParticipantServiceServer() {}

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

func RegisterParticipantServiceServer(s grpc.ServiceRegistrar, srv ParticipantServiceServer) {
	s.RegisterService(&ParticipantService_ServiceDesc, srv)
}

func _ParticipantService_RegisterParticipant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParticipantPhyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).RegisterParticipant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_RegisterParticipant_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).RegisterParticipant(ctx, req.(*ParticipantPhyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ReportHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParticipantHeartbeatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ReportHeartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ReportHeartbeat_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ReportHeartbeat(ctx, req.(*ParticipantHeartbeatReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ReportAvailable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParticipantAvailReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ReportAvailable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ReportAvailable_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ReportAvailable(ctx, req.(*ParticipantAvailReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ListParticipant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParticipantTenant)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ListParticipant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ListParticipant_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ListParticipant(ctx, req.(*ParticipantTenant))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ListPhyAvailable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParticipantTenant)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ListPhyAvailable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ListPhyAvailable_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ListPhyAvailable(ctx, req.(*ParticipantTenant))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ListPhyInformation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParticipantTenant)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ListPhyInformation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ListPhyInformation_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ListPhyInformation(ctx, req.(*ParticipantTenant))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_RegisterTenant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TenantInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).RegisterTenant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_RegisterTenant_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).RegisterTenant(ctx, req.(*TenantInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ListTenant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TenantInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ListTenant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ListTenant_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ListTenant(ctx, req.(*TenantInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_ApplyList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).ApplyList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_ApplyList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).ApplyList(ctx, req.(*ApplyListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_DeleteList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).DeleteList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_DeleteList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).DeleteList(ctx, req.(*ApplyListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_RestartList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).RestartList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_RestartList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).RestartList(ctx, req.(*ApplyListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_PauseList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).PauseList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_PauseList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).PauseList(ctx, req.(*ApplyListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ParticipantService_StartList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParticipantServiceServer).StartList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ParticipantService_StartList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParticipantServiceServer).StartList(ctx, req.(*ApplyListReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ParticipantService_ServiceDesc is the grpc.ServiceDesc for ParticipantService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ParticipantService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "pcmCore.participantService",
	HandlerType: (*ParticipantServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "registerParticipant",
			Handler:    _ParticipantService_RegisterParticipant_Handler,
		},
		{
			MethodName: "reportHeartbeat",
			Handler:    _ParticipantService_ReportHeartbeat_Handler,
		},
		{
			MethodName: "reportAvailable",
			Handler:    _ParticipantService_ReportAvailable_Handler,
		},
		{
			MethodName: "listParticipant",
			Handler:    _ParticipantService_ListParticipant_Handler,
		},
		{
			MethodName: "listPhyAvailable",
			Handler:    _ParticipantService_ListPhyAvailable_Handler,
		},
		{
			MethodName: "listPhyInformation",
			Handler:    _ParticipantService_ListPhyInformation_Handler,
		},
		{
			MethodName: "registerTenant",
			Handler:    _ParticipantService_RegisterTenant_Handler,
		},
		{
			MethodName: "listTenant",
			Handler:    _ParticipantService_ListTenant_Handler,
		},
		{
			MethodName: "applyList",
			Handler:    _ParticipantService_ApplyList_Handler,
		},
		{
			MethodName: "deleteList",
			Handler:    _ParticipantService_DeleteList_Handler,
		},
		{
			MethodName: "restartList",
			Handler:    _ParticipantService_RestartList_Handler,
		},
		{
			MethodName: "pauseList",
			Handler:    _ParticipantService_PauseList_Handler,
		},
		{
			MethodName: "startList",
			Handler:    _ParticipantService_StartList_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pcmCore.proto",
}
