monitor.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/TheThingsNetwork/api/monitor/monitor.proto

package monitor

import (
	context "context"
	fmt "fmt"
	broker "github.com/TheThingsNetwork/api/broker"
	gateway "github.com/TheThingsNetwork/api/gateway"
	handler "github.com/TheThingsNetwork/api/handler"
	networkserver "github.com/TheThingsNetwork/api/networkserver"
	router "github.com/TheThingsNetwork/api/router"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

func init() {
	proto.RegisterFile("github.com/TheThingsNetwork/api/monitor/monitor.proto", fileDescriptor_4842fb8a8deb1d15)
}
func init() {
	golang_proto.RegisterFile("github.com/TheThingsNetwork/api/monitor/monitor.proto", fileDescriptor_4842fb8a8deb1d15)
}

var fileDescriptor_4842fb8a8deb1d15 = []byte{
	// 514 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x3f, 0x68, 0x14, 0x41,
	0x14, 0xc6, 0x67, 0x04, 0x0d, 0x0c, 0x97, 0x1c, 0xac, 0x44, 0xe1, 0x94, 0x87, 0x56, 0x5a, 0xcd,
	0x82, 0x41, 0x08, 0xa9, 0xcc, 0x79, 0xfe, 0x43, 0x23, 0x87, 0x89, 0x8d, 0xdd, 0x5e, 0x6e, 0xdc,
	0x5d, 0xee, 0x6e, 0x67, 0x99, 0x9d, 0xf5, 0x48, 0x97, 0x32, 0xa5, 0xa5, 0xa5, 0x65, 0xb0, 0x4a,
	0x99, 0x32, 0x65, 0xca, 0x94, 0x29, 0xb3, 0xb3, 0x4d, 0x40, 0x90, 0x94, 0x29, 0x25, 0x3b, 0x6f,
	0x0e, 0xcf, 0xc2, 0x5d, 0x30, 0xd5, 0xbb, 0x37, 0x77, 0xdf, 0x77, 0xf3, 0xfb, 0xe6, 0xcd, 0xb0,
	0xa7, 0x61, 0xac, 0xa3, 0x7c, 0xc0, 0xb7, 0xe5, 0xc4, 0xdf, 0x8a, 0xc4, 0x56, 0x14, 0x27, 0x61,
	0xf6, 0x5e, 0xe8, 0xa9, 0x54, 0x23, 0x3f, 0x48, 0x63, 0x7f, 0x22, 0x93, 0x58, 0x4b, 0xe5, 0x2a,
	0x4f, 0x95, 0xd4, 0xd2, 0x5b, 0xc0, 0xb6, 0x73, 0x2f, 0x94, 0x32, 0x1c, 0x0b, 0xbf, 0x5a, 0x1e,
	0xe4, 0x9f, 0x7d, 0x31, 0x49, 0xf5, 0x8e, 0xfd, 0x55, 0xa7, 0xd6, 0x3c, 0x0c, 0xb4, 0x98, 0x06,
	0x3b, 0xae, 0xa2, 0x6c, 0xa5, 0x4e, 0xa6, 0x64, 0xae, 0x85, 0xc2, 0xd2, 0x54, 0x34, 0x50, 0x72,
	0x24, 0x14, 0x96, 0xa6, 0x1b, 0x8c, 0x82, 0x64, 0x38, 0x16, 0xca, 0x55, 0x94, 0xad, 0xd7, 0xc9,
	0x12, 0xfb, 0x39, 0x13, 0xea, 0x8b, 0x50, 0xf3, 0x9d, 0xb5, 0x78, 0xf2, 0xf3, 0x26, 0x5b, 0xd8,
	0xb0, 0x19, 0x7a, 0xab, 0xac, 0xf5, 0xa1, 0x42, 0xd9, 0xd4, 0x81, 0xce, 0x33, 0x6f, 0x89, 0x23,
	0x99, 0xed, 0x3b, 0x77, 0xb8, 0x0d, 0x99, 0xbb, 0x90, 0xf9, 0x8b, 0xab, 0x90, 0x1f, 0x53, 0x6f,
	0x8d, 0x2d, 0xbe, 0xb2, 0xd1, 0xa1, 0xb4, 0xcd, 0x5d, 0x94, 0xb5, 0xda, 0x67, 0x33, 0xed, 0xc7,
	0x74, 0x1c, 0x27, 0x23, 0x6f, 0xd9, 0xfd, 0xad, 0xed, 0x37, 0x44, 0x96, 0x05, 0xa1, 0xf8, 0x87,
	0x43, 0x8f, 0xb5, 0xd1, 0xa1, 0x27, 0xa7, 0x49, 0xe5, 0x71, 0xd7, 0x79, 0xb8, 0x95, 0x7a, 0x97,
	0x55, 0xd6, 0xea, 0x56, 0x67, 0x32, 0xa3, 0xc7, 0x23, 0xaa, 0x25, 0x78, 0xeb, 0x94, 0x08, 0xf0,
	0xd0, 0x29, 0x7b, 0x62, 0x98, 0xa7, 0xe3, 0x78, 0x3b, 0xd0, 0x62, 0xd8, 0x14, 0xe6, 0x39, 0x5b,
	0xb2, 0x66, 0x7f, 0xb0, 0x38, 0xbb, 0xc6, 0x2c, 0x6b, 0x6c, 0xf1, 0xb5, 0x9d, 0x94, 0xd9, 0x79,
	0xb8, 0xc9, 0xa9, 0xa5, 0x79, 0x37, 0xd3, 0x5e, 0x07, 0x4e, 0x8f, 0xb5, 0xd1, 0xed, 0x7f, 0x78,
	0x5e, 0xb2, 0xdb, 0x38, 0xd6, 0x9b, 0xd5, 0xf0, 0x22, 0xd5, 0x32, 0x9f, 0x1f, 0xe9, 0x3a, 0xb6,
	0xee, 0x2f, 0x7a, 0x5c, 0x00, 0x3d, 0x29, 0x80, 0x9e, 0x16, 0x40, 0xce, 0x0a, 0x20, 0xe7, 0x05,
	0x90, 0x8b, 0x02, 0xc8, 0x65, 0x01, 0x74, 0xd7, 0x00, 0xdd, 0x33, 0x40, 0xf6, 0x0d, 0xd0, 0x03,
	0x03, 0xe4, 0xd0, 0x00, 0x39, 0x32, 0x40, 0x8e, 0x0d, 0xd0, 0x13, 0x03, 0xf4, 0xd4, 0x00, 0x39,
	0x33, 0x40, 0xcf, 0x0d, 0x90, 0x0b, 0x03, 0xf4, 0xd2, 0x00, 0xd9, 0x2d, 0x81, 0xec, 0x95, 0x40,
	0xbf, 0x96, 0x40, 0xbe, 0x95, 0x40, 0xbf, 0x97, 0x40, 0xf6, 0x4b, 0x20, 0x07, 0x25, 0xd0, 0xc3,
	0x12, 0xe8, 0x51, 0x09, 0x94, 0x3d, 0x90, 0x2a, 0xe4, 0x3a, 0x12, 0xba, 0xba, 0xa0, 0xb8, 0x67,
	0x1e, 0xa4, 0x31, 0xc7, 0xe7, 0xab, 0xdb, 0xc2, 0x3b, 0xd8, 0xbf, 0xda, 0x71, 0x9f, 0x7e, 0x7a,
	0xd4, 0xf0, 0x39, 0xfc, 0x71, 0xe3, 0xfe, 0xdf, 0x5f, 0xf3, 0xf5, 0xfe, 0x1b, 0x8e, 0x76, 0x83,
	0x5b, 0x55, 0x04, 0x2b, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xce, 0x31, 0xa1, 0x5f, 0x05,
	0x00, 0x00,
}

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

// 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.SupportPackageIsVersion4

// MonitorClient is the client API for Monitor service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MonitorClient interface {
	RouterStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_RouterStatusClient, error)
	GatewayStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_GatewayStatusClient, error)
	GatewayUplink(ctx context.Context, opts ...grpc.CallOption) (Monitor_GatewayUplinkClient, error)
	GatewayDownlink(ctx context.Context, opts ...grpc.CallOption) (Monitor_GatewayDownlinkClient, error)
	BrokerStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_BrokerStatusClient, error)
	BrokerUplink(ctx context.Context, opts ...grpc.CallOption) (Monitor_BrokerUplinkClient, error)
	BrokerDownlink(ctx context.Context, opts ...grpc.CallOption) (Monitor_BrokerDownlinkClient, error)
	HandlerStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_HandlerStatusClient, error)
	HandlerUplink(ctx context.Context, opts ...grpc.CallOption) (Monitor_HandlerUplinkClient, error)
	HandlerDownlink(ctx context.Context, opts ...grpc.CallOption) (Monitor_HandlerDownlinkClient, error)
	NetworkServerStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_NetworkServerStatusClient, error)
}

type monitorClient struct {
	cc *grpc.ClientConn
}

func NewMonitorClient(cc *grpc.ClientConn) MonitorClient {
	return &monitorClient{cc}
}

func (c *monitorClient) RouterStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_RouterStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[0], "/monitor.Monitor/RouterStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorRouterStatusClient{stream}
	return x, nil
}

type Monitor_RouterStatusClient interface {
	Send(*router.Status) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorRouterStatusClient struct {
	grpc.ClientStream
}

func (x *monitorRouterStatusClient) Send(m *router.Status) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorRouterStatusClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) GatewayStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_GatewayStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[1], "/monitor.Monitor/GatewayStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorGatewayStatusClient{stream}
	return x, nil
}

type Monitor_GatewayStatusClient interface {
	Send(*gateway.Status) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorGatewayStatusClient struct {
	grpc.ClientStream
}

func (x *monitorGatewayStatusClient) Send(m *gateway.Status) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorGatewayStatusClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) GatewayUplink(ctx context.Context, opts ...grpc.CallOption) (Monitor_GatewayUplinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[2], "/monitor.Monitor/GatewayUplink", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorGatewayUplinkClient{stream}
	return x, nil
}

type Monitor_GatewayUplinkClient interface {
	Send(*router.UplinkMessage) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorGatewayUplinkClient struct {
	grpc.ClientStream
}

func (x *monitorGatewayUplinkClient) Send(m *router.UplinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorGatewayUplinkClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) GatewayDownlink(ctx context.Context, opts ...grpc.CallOption) (Monitor_GatewayDownlinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[3], "/monitor.Monitor/GatewayDownlink", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorGatewayDownlinkClient{stream}
	return x, nil
}

type Monitor_GatewayDownlinkClient interface {
	Send(*router.DownlinkMessage) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorGatewayDownlinkClient struct {
	grpc.ClientStream
}

func (x *monitorGatewayDownlinkClient) Send(m *router.DownlinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorGatewayDownlinkClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) BrokerStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_BrokerStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[4], "/monitor.Monitor/BrokerStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorBrokerStatusClient{stream}
	return x, nil
}

type Monitor_BrokerStatusClient interface {
	Send(*broker.Status) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorBrokerStatusClient struct {
	grpc.ClientStream
}

func (x *monitorBrokerStatusClient) Send(m *broker.Status) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorBrokerStatusClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) BrokerUplink(ctx context.Context, opts ...grpc.CallOption) (Monitor_BrokerUplinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[5], "/monitor.Monitor/BrokerUplink", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorBrokerUplinkClient{stream}
	return x, nil
}

type Monitor_BrokerUplinkClient interface {
	Send(*broker.DeduplicatedUplinkMessage) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorBrokerUplinkClient struct {
	grpc.ClientStream
}

func (x *monitorBrokerUplinkClient) Send(m *broker.DeduplicatedUplinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorBrokerUplinkClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) BrokerDownlink(ctx context.Context, opts ...grpc.CallOption) (Monitor_BrokerDownlinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[6], "/monitor.Monitor/BrokerDownlink", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorBrokerDownlinkClient{stream}
	return x, nil
}

type Monitor_BrokerDownlinkClient interface {
	Send(*broker.DownlinkMessage) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorBrokerDownlinkClient struct {
	grpc.ClientStream
}

func (x *monitorBrokerDownlinkClient) Send(m *broker.DownlinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorBrokerDownlinkClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) HandlerStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_HandlerStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[7], "/monitor.Monitor/HandlerStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorHandlerStatusClient{stream}
	return x, nil
}

type Monitor_HandlerStatusClient interface {
	Send(*handler.Status) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorHandlerStatusClient struct {
	grpc.ClientStream
}

func (x *monitorHandlerStatusClient) Send(m *handler.Status) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorHandlerStatusClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) HandlerUplink(ctx context.Context, opts ...grpc.CallOption) (Monitor_HandlerUplinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[8], "/monitor.Monitor/HandlerUplink", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorHandlerUplinkClient{stream}
	return x, nil
}

type Monitor_HandlerUplinkClient interface {
	Send(*broker.DeduplicatedUplinkMessage) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorHandlerUplinkClient struct {
	grpc.ClientStream
}

func (x *monitorHandlerUplinkClient) Send(m *broker.DeduplicatedUplinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorHandlerUplinkClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) HandlerDownlink(ctx context.Context, opts ...grpc.CallOption) (Monitor_HandlerDownlinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[9], "/monitor.Monitor/HandlerDownlink", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorHandlerDownlinkClient{stream}
	return x, nil
}

type Monitor_HandlerDownlinkClient interface {
	Send(*broker.DownlinkMessage) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorHandlerDownlinkClient struct {
	grpc.ClientStream
}

func (x *monitorHandlerDownlinkClient) Send(m *broker.DownlinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorHandlerDownlinkClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *monitorClient) NetworkServerStatus(ctx context.Context, opts ...grpc.CallOption) (Monitor_NetworkServerStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Monitor_serviceDesc.Streams[10], "/monitor.Monitor/NetworkServerStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorNetworkServerStatusClient{stream}
	return x, nil
}

type Monitor_NetworkServerStatusClient interface {
	Send(*networkserver.Status) error
	CloseAndRecv() (*types.Empty, error)
	grpc.ClientStream
}

type monitorNetworkServerStatusClient struct {
	grpc.ClientStream
}

func (x *monitorNetworkServerStatusClient) Send(m *networkserver.Status) error {
	return x.ClientStream.SendMsg(m)
}

func (x *monitorNetworkServerStatusClient) CloseAndRecv() (*types.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(types.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// MonitorServer is the server API for Monitor service.
type MonitorServer interface {
	RouterStatus(Monitor_RouterStatusServer) error
	GatewayStatus(Monitor_GatewayStatusServer) error
	GatewayUplink(Monitor_GatewayUplinkServer) error
	GatewayDownlink(Monitor_GatewayDownlinkServer) error
	BrokerStatus(Monitor_BrokerStatusServer) error
	BrokerUplink(Monitor_BrokerUplinkServer) error
	BrokerDownlink(Monitor_BrokerDownlinkServer) error
	HandlerStatus(Monitor_HandlerStatusServer) error
	HandlerUplink(Monitor_HandlerUplinkServer) error
	HandlerDownlink(Monitor_HandlerDownlinkServer) error
	NetworkServerStatus(Monitor_NetworkServerStatusServer) error
}

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

func (*UnimplementedMonitorServer) RouterStatus(srv Monitor_RouterStatusServer) error {
	return status.Errorf(codes.Unimplemented, "method RouterStatus not implemented")
}
func (*UnimplementedMonitorServer) GatewayStatus(srv Monitor_GatewayStatusServer) error {
	return status.Errorf(codes.Unimplemented, "method GatewayStatus not implemented")
}
func (*UnimplementedMonitorServer) GatewayUplink(srv Monitor_GatewayUplinkServer) error {
	return status.Errorf(codes.Unimplemented, "method GatewayUplink not implemented")
}
func (*UnimplementedMonitorServer) GatewayDownlink(srv Monitor_GatewayDownlinkServer) error {
	return status.Errorf(codes.Unimplemented, "method GatewayDownlink not implemented")
}
func (*UnimplementedMonitorServer) BrokerStatus(srv Monitor_BrokerStatusServer) error {
	return status.Errorf(codes.Unimplemented, "method BrokerStatus not implemented")
}
func (*UnimplementedMonitorServer) BrokerUplink(srv Monitor_BrokerUplinkServer) error {
	return status.Errorf(codes.Unimplemented, "method BrokerUplink not implemented")
}
func (*UnimplementedMonitorServer) BrokerDownlink(srv Monitor_BrokerDownlinkServer) error {
	return status.Errorf(codes.Unimplemented, "method BrokerDownlink not implemented")
}
func (*UnimplementedMonitorServer) HandlerStatus(srv Monitor_HandlerStatusServer) error {
	return status.Errorf(codes.Unimplemented, "method HandlerStatus not implemented")
}
func (*UnimplementedMonitorServer) HandlerUplink(srv Monitor_HandlerUplinkServer) error {
	return status.Errorf(codes.Unimplemented, "method HandlerUplink not implemented")
}
func (*UnimplementedMonitorServer) HandlerDownlink(srv Monitor_HandlerDownlinkServer) error {
	return status.Errorf(codes.Unimplemented, "method HandlerDownlink not implemented")
}
func (*UnimplementedMonitorServer) NetworkServerStatus(srv Monitor_NetworkServerStatusServer) error {
	return status.Errorf(codes.Unimplemented, "method NetworkServerStatus not implemented")
}

func RegisterMonitorServer(s *grpc.Server, srv MonitorServer) {
	s.RegisterService(&_Monitor_serviceDesc, srv)
}

func _Monitor_RouterStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).RouterStatus(&monitorRouterStatusServer{stream})
}

type Monitor_RouterStatusServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*router.Status, error)
	grpc.ServerStream
}

type monitorRouterStatusServer struct {
	grpc.ServerStream
}

func (x *monitorRouterStatusServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorRouterStatusServer) Recv() (*router.Status, error) {
	m := new(router.Status)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_GatewayStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).GatewayStatus(&monitorGatewayStatusServer{stream})
}

type Monitor_GatewayStatusServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*gateway.Status, error)
	grpc.ServerStream
}

type monitorGatewayStatusServer struct {
	grpc.ServerStream
}

func (x *monitorGatewayStatusServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorGatewayStatusServer) Recv() (*gateway.Status, error) {
	m := new(gateway.Status)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_GatewayUplink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).GatewayUplink(&monitorGatewayUplinkServer{stream})
}

type Monitor_GatewayUplinkServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*router.UplinkMessage, error)
	grpc.ServerStream
}

type monitorGatewayUplinkServer struct {
	grpc.ServerStream
}

func (x *monitorGatewayUplinkServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorGatewayUplinkServer) Recv() (*router.UplinkMessage, error) {
	m := new(router.UplinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_GatewayDownlink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).GatewayDownlink(&monitorGatewayDownlinkServer{stream})
}

type Monitor_GatewayDownlinkServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*router.DownlinkMessage, error)
	grpc.ServerStream
}

type monitorGatewayDownlinkServer struct {
	grpc.ServerStream
}

func (x *monitorGatewayDownlinkServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorGatewayDownlinkServer) Recv() (*router.DownlinkMessage, error) {
	m := new(router.DownlinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_BrokerStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).BrokerStatus(&monitorBrokerStatusServer{stream})
}

type Monitor_BrokerStatusServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*broker.Status, error)
	grpc.ServerStream
}

type monitorBrokerStatusServer struct {
	grpc.ServerStream
}

func (x *monitorBrokerStatusServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorBrokerStatusServer) Recv() (*broker.Status, error) {
	m := new(broker.Status)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_BrokerUplink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).BrokerUplink(&monitorBrokerUplinkServer{stream})
}

type Monitor_BrokerUplinkServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*broker.DeduplicatedUplinkMessage, error)
	grpc.ServerStream
}

type monitorBrokerUplinkServer struct {
	grpc.ServerStream
}

func (x *monitorBrokerUplinkServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorBrokerUplinkServer) Recv() (*broker.DeduplicatedUplinkMessage, error) {
	m := new(broker.DeduplicatedUplinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_BrokerDownlink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).BrokerDownlink(&monitorBrokerDownlinkServer{stream})
}

type Monitor_BrokerDownlinkServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*broker.DownlinkMessage, error)
	grpc.ServerStream
}

type monitorBrokerDownlinkServer struct {
	grpc.ServerStream
}

func (x *monitorBrokerDownlinkServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorBrokerDownlinkServer) Recv() (*broker.DownlinkMessage, error) {
	m := new(broker.DownlinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_HandlerStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).HandlerStatus(&monitorHandlerStatusServer{stream})
}

type Monitor_HandlerStatusServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*handler.Status, error)
	grpc.ServerStream
}

type monitorHandlerStatusServer struct {
	grpc.ServerStream
}

func (x *monitorHandlerStatusServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorHandlerStatusServer) Recv() (*handler.Status, error) {
	m := new(handler.Status)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_HandlerUplink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).HandlerUplink(&monitorHandlerUplinkServer{stream})
}

type Monitor_HandlerUplinkServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*broker.DeduplicatedUplinkMessage, error)
	grpc.ServerStream
}

type monitorHandlerUplinkServer struct {
	grpc.ServerStream
}

func (x *monitorHandlerUplinkServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorHandlerUplinkServer) Recv() (*broker.DeduplicatedUplinkMessage, error) {
	m := new(broker.DeduplicatedUplinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_HandlerDownlink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).HandlerDownlink(&monitorHandlerDownlinkServer{stream})
}

type Monitor_HandlerDownlinkServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*broker.DownlinkMessage, error)
	grpc.ServerStream
}

type monitorHandlerDownlinkServer struct {
	grpc.ServerStream
}

func (x *monitorHandlerDownlinkServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorHandlerDownlinkServer) Recv() (*broker.DownlinkMessage, error) {
	m := new(broker.DownlinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Monitor_NetworkServerStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonitorServer).NetworkServerStatus(&monitorNetworkServerStatusServer{stream})
}

type Monitor_NetworkServerStatusServer interface {
	SendAndClose(*types.Empty) error
	Recv() (*networkserver.Status, error)
	grpc.ServerStream
}

type monitorNetworkServerStatusServer struct {
	grpc.ServerStream
}

func (x *monitorNetworkServerStatusServer) SendAndClose(m *types.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *monitorNetworkServerStatusServer) Recv() (*networkserver.Status, error) {
	m := new(networkserver.Status)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Monitor_serviceDesc = grpc.ServiceDesc{
	ServiceName: "monitor.Monitor",
	HandlerType: (*MonitorServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RouterStatus",
			Handler:       _Monitor_RouterStatus_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GatewayStatus",
			Handler:       _Monitor_GatewayStatus_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GatewayUplink",
			Handler:       _Monitor_GatewayUplink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GatewayDownlink",
			Handler:       _Monitor_GatewayDownlink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "BrokerStatus",
			Handler:       _Monitor_BrokerStatus_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "BrokerUplink",
			Handler:       _Monitor_BrokerUplink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "BrokerDownlink",
			Handler:       _Monitor_BrokerDownlink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "HandlerStatus",
			Handler:       _Monitor_HandlerStatus_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "HandlerUplink",
			Handler:       _Monitor_HandlerUplink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "HandlerDownlink",
			Handler:       _Monitor_HandlerDownlink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "NetworkServerStatus",
			Handler:       _Monitor_NetworkServerStatus_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "github.com/TheThingsNetwork/api/monitor/monitor.proto",
}