gosdnCLI.pb.go

	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
	0x22, 0x60, 0x0a, 0x10, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71,
	0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x75, 0x69, 0x64, 0x50, 0x4e, 0x44, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x75, 0x75, 0x69, 0x64, 0x50, 0x4e, 0x44, 0x12, 0x1e,
	0x0a, 0x0a, 0x75, 0x75, 0x69, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01,
	0x28, 0x09, 0x52, 0x0a, 0x75, 0x75, 0x69, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x12, 0x12,
	0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61,
	0x74, 0x68, 0x22, 0x2a, 0x0a, 0x0e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x47, 0x65, 0x74, 0x52,
	0x65, 0x70, 0x6c, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x1c,
	0x0a, 0x08, 0x4c, 0x6f, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f,
	0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6c, 0x6f, 0x67, 0x32, 0xb0, 0x05, 0x0a,
	0x07, 0x47, 0x72, 0x70, 0x63, 0x43, 0x6c, 0x69, 0x12, 0x34, 0x0a, 0x08, 0x53, 0x61, 0x79, 0x48,
	0x65, 0x6c, 0x6c, 0x6f, 0x12, 0x13, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x48, 0x65, 0x6c,
	0x6c, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x2e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12, 0x3a,
	0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x16, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65,
	0x73, 0x74, 0x1a, 0x14, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64,
	0x6f, 0x77, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12, 0x3e, 0x0a, 0x0f, 0x43, 0x72,
	0x65, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x67, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x16, 0x2e,
	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
	0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x0f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x4c, 0x6f,
	0x67, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x30, 0x01, 0x12, 0x35, 0x0a, 0x0b, 0x54, 0x41,
	0x50, 0x49, 0x47, 0x65, 0x74, 0x45, 0x64, 0x67, 0x65, 0x12, 0x12, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x2e, 0x54, 0x41, 0x50, 0x49, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x10, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54, 0x41, 0x50, 0x49, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22,
	0x00, 0x12, 0x39, 0x0a, 0x0f, 0x54, 0x41, 0x50, 0x49, 0x47, 0x65, 0x74, 0x45, 0x64, 0x67, 0x65,
	0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54, 0x41, 0x50,
	0x49, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x10, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
	0x2e, 0x54, 0x41, 0x50, 0x49, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12, 0x35, 0x0a, 0x0b,
	0x54, 0x41, 0x50, 0x49, 0x47, 0x65, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x12, 0x12, 0x2e, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x2e, 0x54, 0x41, 0x50, 0x49, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
	0x10, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54, 0x41, 0x50, 0x49, 0x52, 0x65, 0x70, 0x6c,
	0x79, 0x22, 0x00, 0x12, 0x3d, 0x0a, 0x09, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x4e, 0x44,
	0x12, 0x17, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50,
	0x4e, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x15, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x4e, 0x44, 0x52, 0x65, 0x70, 0x6c, 0x79,
	0x22, 0x00, 0x12, 0x3b, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x4e, 0x44, 0x73,
	0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
	0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x13, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
	0x2e, 0x41, 0x6c, 0x6c, 0x50, 0x4e, 0x44, 0x73, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12,
	0x43, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x53, 0x42, 0x49, 0x4e, 0x61, 0x6d, 0x65,
	0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x17, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x2e, 0x41, 0x6c, 0x6c, 0x53, 0x42, 0x49, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x70,
	0x6c, 0x79, 0x22, 0x00, 0x12, 0x3d, 0x0a, 0x09, 0x41, 0x64, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63,
	0x65, 0x12, 0x17, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x41, 0x64, 0x64, 0x44, 0x65, 0x76,
	0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x15, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x2e, 0x41, 0x64, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x52, 0x65, 0x70, 0x6c,
	0x79, 0x22, 0x00, 0x12, 0x4a, 0x0a, 0x16, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x44, 0x65, 0x76,
	0x69, 0x63, 0x65, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x47, 0x65, 0x74, 0x52,
	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x15, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x44,
	0x65, 0x76, 0x69, 0x63, 0x65, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x42,
	0x50, 0x0a, 0x1e, 0x64, 0x65, 0x2e, 0x68, 0x2d, 0x64, 0x61, 0x2e, 0x66, 0x62, 0x69, 0x2e, 0x67,
	0x6f, 0x73, 0x64, 0x6e, 0x2e, 0x63, 0x6c, 0x69, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63,
	0x65, 0x42, 0x0c, 0x63, 0x6c, 0x69, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x50,
	0x01, 0x5a, 0x1e, 0x67, 0x69, 0x74, 0x6c, 0x61, 0x62, 0x2e, 0x66, 0x62, 0x69, 0x2e, 0x68, 0x2d,
	0x64, 0x61, 0x2e, 0x64, 0x65, 0x2f, 0x63, 0x6f, 0x63, 0x73, 0x6e, 0x2f, 0x67, 0x6f, 0x73, 0x64,
	0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_gosdnCLI_proto_rawDescOnce sync.Once
	file_gosdnCLI_proto_rawDescData = file_gosdnCLI_proto_rawDesc
)

func file_gosdnCLI_proto_rawDescGZIP() []byte {
	file_gosdnCLI_proto_rawDescOnce.Do(func() {
		file_gosdnCLI_proto_rawDescData = protoimpl.X.CompressGZIP(file_gosdnCLI_proto_rawDescData)
	})
	return file_gosdnCLI_proto_rawDescData
}

var file_gosdnCLI_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
var file_gosdnCLI_proto_goTypes = []interface{}{
	(*HelloRequest)(nil),     // 0: proto.HelloRequest
	(*HelloReply)(nil),       // 1: proto.HelloReply
	(*ShutdownRequest)(nil),  // 2: proto.ShutdownRequest
	(*ShutdownReply)(nil),    // 3: proto.ShutdownReply
	(*TAPIRequest)(nil),      // 4: proto.TAPIRequest
	(*TAPIReply)(nil),        // 5: proto.TAPIReply
	(*CreatePNDRequest)(nil), // 6: proto.CreatePNDRequest
	(*AllSBINamesReply)(nil), // 7: proto.AllSBINamesReply
	(*CreatePNDReply)(nil),   // 8: proto.CreatePNDReply
	(*AllPNDsReply)(nil),     // 9: proto.AllPNDsReply
	(*PND)(nil),              // 10: proto.PND
	(*Device)(nil),           // 11: proto.Device
	(*AddDeviceRequest)(nil), // 12: proto.AddDeviceRequest
	(*AddDeviceReply)(nil),   // 13: proto.AddDeviceReply
	(*DeviceGetRequest)(nil), // 14: proto.DeviceGetRequest
	(*DeviceGetReply)(nil),   // 15: proto.DeviceGetReply
	(*LogReply)(nil),         // 16: proto.LogReply
	(*emptypb.Empty)(nil),    // 17: google.protobuf.Empty
}
var file_gosdnCLI_proto_depIdxs = []int32{
	10, // 0: proto.AllPNDsReply.pnds:type_name -> proto.PND
	11, // 1: proto.PND.devices:type_name -> proto.Device
	11, // 2: proto.AddDeviceRequest.device:type_name -> proto.Device
	0,  // 3: proto.GrpcCli.SayHello:input_type -> proto.HelloRequest
	2,  // 4: proto.GrpcCli.Shutdown:input_type -> proto.ShutdownRequest
	17, // 5: proto.GrpcCli.CreateLogStream:input_type -> google.protobuf.Empty
	4,  // 6: proto.GrpcCli.TAPIGetEdge:input_type -> proto.TAPIRequest
	4,  // 7: proto.GrpcCli.TAPIGetEdgeNode:input_type -> proto.TAPIRequest
	4,  // 8: proto.GrpcCli.TAPIGetLink:input_type -> proto.TAPIRequest
	6,  // 9: proto.GrpcCli.CreatePND:input_type -> proto.CreatePNDRequest
	17, // 10: proto.GrpcCli.GetAllPNDs:input_type -> google.protobuf.Empty
	17, // 11: proto.GrpcCli.GetAllSBINames:input_type -> google.protobuf.Empty
	12, // 12: proto.GrpcCli.AddDevice:input_type -> proto.AddDeviceRequest
	14, // 13: proto.GrpcCli.HandleDeviceGetRequest:input_type -> proto.DeviceGetRequest
	1,  // 14: proto.GrpcCli.SayHello:output_type -> proto.HelloReply
	3,  // 15: proto.GrpcCli.Shutdown:output_type -> proto.ShutdownReply
	16, // 16: proto.GrpcCli.CreateLogStream:output_type -> proto.LogReply
	5,  // 17: proto.GrpcCli.TAPIGetEdge:output_type -> proto.TAPIReply
	5,  // 18: proto.GrpcCli.TAPIGetEdgeNode:output_type -> proto.TAPIReply
	5,  // 19: proto.GrpcCli.TAPIGetLink:output_type -> proto.TAPIReply
	8,  // 20: proto.GrpcCli.CreatePND:output_type -> proto.CreatePNDReply
	9,  // 21: proto.GrpcCli.GetAllPNDs:output_type -> proto.AllPNDsReply
	7,  // 22: proto.GrpcCli.GetAllSBINames:output_type -> proto.AllSBINamesReply
	13, // 23: proto.GrpcCli.AddDevice:output_type -> proto.AddDeviceReply
	15, // 24: proto.GrpcCli.HandleDeviceGetRequest:output_type -> proto.DeviceGetReply
	14, // [14:25] is the sub-list for method output_type
	3,  // [3:14] is the sub-list for method input_type
	3,  // [3:3] is the sub-list for extension type_name
	3,  // [3:3] is the sub-list for extension extendee
	0,  // [0:3] is the sub-list for field type_name
}

func init() { file_gosdnCLI_proto_init() }
func file_gosdnCLI_proto_init() {
	if File_gosdnCLI_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_gosdnCLI_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*HelloRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*HelloReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ShutdownRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ShutdownReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TAPIRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TAPIReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreatePNDRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AllSBINamesReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreatePNDReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AllPNDsReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*PND); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Device); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AddDeviceRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AddDeviceReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*DeviceGetRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*DeviceGetReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_gosdnCLI_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LogReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_gosdnCLI_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   17,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_gosdnCLI_proto_goTypes,
		DependencyIndexes: file_gosdnCLI_proto_depIdxs,
		MessageInfos:      file_gosdnCLI_proto_msgTypes,
	}.Build()
	File_gosdnCLI_proto = out.File
	file_gosdnCLI_proto_rawDesc = nil
	file_gosdnCLI_proto_goTypes = nil
	file_gosdnCLI_proto_depIdxs = nil
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// GrpcCliClient is the client API for GrpcCli service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GrpcCliClient interface {
	// Sends a greeting
	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
	// Shutdown goSDN
	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownReply, error)
	// creates a stream to receive goSDN logs
	CreateLogStream(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (GrpcCli_CreateLogStreamClient, error)
	// By now solely TAPI specific calls can be issued from the grpc-cli
	// TAPIGetEdge
	TAPIGetEdge(ctx context.Context, in *TAPIRequest, opts ...grpc.CallOption) (*TAPIReply, error)
	//TAPIGetEdgeNode
	TAPIGetEdgeNode(ctx context.Context, in *TAPIRequest, opts ...grpc.CallOption) (*TAPIReply, error)
	// TAPIGetLink
	TAPIGetLink(ctx context.Context, in *TAPIRequest, opts ...grpc.CallOption) (*TAPIReply, error)
	// CreatePND
	CreatePND(ctx context.Context, in *CreatePNDRequest, opts ...grpc.CallOption) (*CreatePNDReply, error)
	// GetAllPNDs
	GetAllPNDs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AllPNDsReply, error)
	// GetAllSBIs
	GetAllSBINames(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AllSBINamesReply, error)
	// AddDevice
	AddDevice(ctx context.Context, in *AddDeviceRequest, opts ...grpc.CallOption) (*AddDeviceReply, error)
	// HandleDeviceGetRequest
	HandleDeviceGetRequest(ctx context.Context, in *DeviceGetRequest, opts ...grpc.CallOption) (*DeviceGetReply, error)
}

type grpcCliClient struct {
	cc grpc.ClientConnInterface
}

func NewGrpcCliClient(cc grpc.ClientConnInterface) GrpcCliClient {
	return &grpcCliClient{cc}
}

func (c *grpcCliClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/SayHello", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownReply, error) {
	out := new(ShutdownReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/Shutdown", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) CreateLogStream(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (GrpcCli_CreateLogStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_GrpcCli_serviceDesc.Streams[0], "/proto.GrpcCli/CreateLogStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcCliCreateLogStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GrpcCli_CreateLogStreamClient interface {
	Recv() (*LogReply, error)
	grpc.ClientStream
}

type grpcCliCreateLogStreamClient struct {
	grpc.ClientStream
}

func (x *grpcCliCreateLogStreamClient) Recv() (*LogReply, error) {
	m := new(LogReply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *grpcCliClient) TAPIGetEdge(ctx context.Context, in *TAPIRequest, opts ...grpc.CallOption) (*TAPIReply, error) {
	out := new(TAPIReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/TAPIGetEdge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) TAPIGetEdgeNode(ctx context.Context, in *TAPIRequest, opts ...grpc.CallOption) (*TAPIReply, error) {
	out := new(TAPIReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/TAPIGetEdgeNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) TAPIGetLink(ctx context.Context, in *TAPIRequest, opts ...grpc.CallOption) (*TAPIReply, error) {
	out := new(TAPIReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/TAPIGetLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) CreatePND(ctx context.Context, in *CreatePNDRequest, opts ...grpc.CallOption) (*CreatePNDReply, error) {
	out := new(CreatePNDReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/CreatePND", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) GetAllPNDs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AllPNDsReply, error) {
	out := new(AllPNDsReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/GetAllPNDs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) GetAllSBINames(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AllSBINamesReply, error) {
	out := new(AllSBINamesReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/GetAllSBINames", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) AddDevice(ctx context.Context, in *AddDeviceRequest, opts ...grpc.CallOption) (*AddDeviceReply, error) {
	out := new(AddDeviceReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/AddDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcCliClient) HandleDeviceGetRequest(ctx context.Context, in *DeviceGetRequest, opts ...grpc.CallOption) (*DeviceGetReply, error) {
	out := new(DeviceGetReply)
	err := c.cc.Invoke(ctx, "/proto.GrpcCli/HandleDeviceGetRequest", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GrpcCliServer is the server API for GrpcCli service.
type GrpcCliServer interface {
	// Sends a greeting
	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
	// Shutdown goSDN
	Shutdown(context.Context, *ShutdownRequest) (*ShutdownReply, error)
	// creates a stream to receive goSDN logs
	CreateLogStream(*emptypb.Empty, GrpcCli_CreateLogStreamServer) error
	// By now solely TAPI specific calls can be issued from the grpc-cli
	// TAPIGetEdge
	TAPIGetEdge(context.Context, *TAPIRequest) (*TAPIReply, error)
	//TAPIGetEdgeNode
	TAPIGetEdgeNode(context.Context, *TAPIRequest) (*TAPIReply, error)
	// TAPIGetLink
	TAPIGetLink(context.Context, *TAPIRequest) (*TAPIReply, error)
	// CreatePND
	CreatePND(context.Context, *CreatePNDRequest) (*CreatePNDReply, error)
	// GetAllPNDs
	GetAllPNDs(context.Context, *emptypb.Empty) (*AllPNDsReply, error)
	// GetAllSBIs
	GetAllSBINames(context.Context, *emptypb.Empty) (*AllSBINamesReply, error)
	// AddDevice
	AddDevice(context.Context, *AddDeviceRequest) (*AddDeviceReply, error)
	// HandleDeviceGetRequest
	HandleDeviceGetRequest(context.Context, *DeviceGetRequest) (*DeviceGetReply, error)
}

// UnimplementedGrpcCliServer can be embedded to have forward compatible implementations.
type UnimplementedGrpcCliServer struct {
}

func (*UnimplementedGrpcCliServer) SayHello(context.Context, *HelloRequest) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}
func (*UnimplementedGrpcCliServer) Shutdown(context.Context, *ShutdownRequest) (*ShutdownReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented")
}
func (*UnimplementedGrpcCliServer) CreateLogStream(*emptypb.Empty, GrpcCli_CreateLogStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method CreateLogStream not implemented")
}
func (*UnimplementedGrpcCliServer) TAPIGetEdge(context.Context, *TAPIRequest) (*TAPIReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TAPIGetEdge not implemented")
}
func (*UnimplementedGrpcCliServer) TAPIGetEdgeNode(context.Context, *TAPIRequest) (*TAPIReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TAPIGetEdgeNode not implemented")
}
func (*UnimplementedGrpcCliServer) TAPIGetLink(context.Context, *TAPIRequest) (*TAPIReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TAPIGetLink not implemented")
}
func (*UnimplementedGrpcCliServer) CreatePND(context.Context, *CreatePNDRequest) (*CreatePNDReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePND not implemented")
}
func (*UnimplementedGrpcCliServer) GetAllPNDs(context.Context, *emptypb.Empty) (*AllPNDsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllPNDs not implemented")
}
func (*UnimplementedGrpcCliServer) GetAllSBINames(context.Context, *emptypb.Empty) (*AllSBINamesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllSBINames not implemented")
}
func (*UnimplementedGrpcCliServer) AddDevice(context.Context, *AddDeviceRequest) (*AddDeviceReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddDevice not implemented")
}
func (*UnimplementedGrpcCliServer) HandleDeviceGetRequest(context.Context, *DeviceGetRequest) (*DeviceGetReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HandleDeviceGetRequest not implemented")
}

func RegisterGrpcCliServer(s *grpc.Server, srv GrpcCliServer) {
	s.RegisterService(&_GrpcCli_serviceDesc, srv)
}

func _GrpcCli_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HelloRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).SayHello(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/SayHello",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).SayHello(ctx, req.(*HelloRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShutdownRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).Shutdown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/Shutdown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).Shutdown(ctx, req.(*ShutdownRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_CreateLogStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcCliServer).CreateLogStream(m, &grpcCliCreateLogStreamServer{stream})
}

type GrpcCli_CreateLogStreamServer interface {
	Send(*LogReply) error
	grpc.ServerStream
}

type grpcCliCreateLogStreamServer struct {
	grpc.ServerStream
}

func (x *grpcCliCreateLogStreamServer) Send(m *LogReply) error {
	return x.ServerStream.SendMsg(m)
}

func _GrpcCli_TAPIGetEdge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TAPIRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).TAPIGetEdge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/TAPIGetEdge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).TAPIGetEdge(ctx, req.(*TAPIRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_TAPIGetEdgeNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TAPIRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).TAPIGetEdgeNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/TAPIGetEdgeNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).TAPIGetEdgeNode(ctx, req.(*TAPIRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_TAPIGetLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TAPIRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).TAPIGetLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/TAPIGetLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).TAPIGetLink(ctx, req.(*TAPIRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_CreatePND_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePNDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).CreatePND(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/CreatePND",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).CreatePND(ctx, req.(*CreatePNDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_GetAllPNDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).GetAllPNDs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/GetAllPNDs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).GetAllPNDs(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_GetAllSBINames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).GetAllSBINames(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/GetAllSBINames",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).GetAllSBINames(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_AddDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).AddDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/AddDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).AddDevice(ctx, req.(*AddDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcCli_HandleDeviceGetRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcCliServer).HandleDeviceGetRequest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.GrpcCli/HandleDeviceGetRequest",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcCliServer).HandleDeviceGetRequest(ctx, req.(*DeviceGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _GrpcCli_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.GrpcCli",
	HandlerType: (*GrpcCliServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SayHello",
			Handler:    _GrpcCli_SayHello_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _GrpcCli_Shutdown_Handler,
		},
		{
			MethodName: "TAPIGetEdge",
			Handler:    _GrpcCli_TAPIGetEdge_Handler,
		},
		{
			MethodName: "TAPIGetEdgeNode",
			Handler:    _GrpcCli_TAPIGetEdgeNode_Handler,
		},
		{
			MethodName: "TAPIGetLink",
			Handler:    _GrpcCli_TAPIGetLink_Handler,
		},
		{
			MethodName: "CreatePND",
			Handler:    _GrpcCli_CreatePND_Handler,
		},
		{
			MethodName: "GetAllPNDs",
			Handler:    _GrpcCli_GetAllPNDs_Handler,
		},
		{
			MethodName: "GetAllSBINames",
			Handler:    _GrpcCli_GetAllSBINames_Handler,
		},
		{
			MethodName: "AddDevice",
			Handler:    _GrpcCli_AddDevice_Handler,
		},
		{
			MethodName: "HandleDeviceGetRequest",
			Handler:    _GrpcCli_HandleDeviceGetRequest_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "CreateLogStream",
			Handler:       _GrpcCli_CreateLogStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "gosdnCLI.proto",
}