// Code generated by protoc-gen-go. DO NOT EDIT.
// source: ribsapi.proto

package ribsapi

import (
	context "context"
	fmt "fmt"
	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 _ = 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.ProtoPackageIsVersion3 // please upgrade the proto package

type RibUpdate struct {
	Rt                   string   `protobuf:"bytes,1,opt,name=rt,proto3" json:"rt,omitempty"`
	Path                 []byte   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RibUpdate) Reset()         { *m = RibUpdate{} }
func (m *RibUpdate) String() string { return proto.CompactTextString(m) }
func (*RibUpdate) ProtoMessage()    {}
func (*RibUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{0}
}

func (m *RibUpdate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RibUpdate.Unmarshal(m, b)
}
func (m *RibUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RibUpdate.Marshal(b, m, deterministic)
}
func (m *RibUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RibUpdate.Merge(m, src)
}
func (m *RibUpdate) XXX_Size() int {
	return xxx_messageInfo_RibUpdate.Size(m)
}
func (m *RibUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_RibUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_RibUpdate proto.InternalMessageInfo

func (m *RibUpdate) GetRt() string {
	if m != nil {
		return m.Rt
	}
	return ""
}

func (m *RibUpdate) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

type ModRibReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ModRibReply) Reset()         { *m = ModRibReply{} }
func (m *ModRibReply) String() string { return proto.CompactTextString(m) }
func (*ModRibReply) ProtoMessage()    {}
func (*ModRibReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{1}
}

func (m *ModRibReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ModRibReply.Unmarshal(m, b)
}
func (m *ModRibReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ModRibReply.Marshal(b, m, deterministic)
}
func (m *ModRibReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ModRibReply.Merge(m, src)
}
func (m *ModRibReply) XXX_Size() int {
	return xxx_messageInfo_ModRibReply.Size(m)
}
func (m *ModRibReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ModRibReply.DiscardUnknown(m)
}

var xxx_messageInfo_ModRibReply proto.InternalMessageInfo

type MonitorRibRequest struct {
	Rt                   string   `protobuf:"bytes,1,opt,name=rt,proto3" json:"rt,omitempty"`
	NId                  uint32   `protobuf:"varint,2,opt,name=n_id,json=nId,proto3" json:"n_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MonitorRibRequest) Reset()         { *m = MonitorRibRequest{} }
func (m *MonitorRibRequest) String() string { return proto.CompactTextString(m) }
func (*MonitorRibRequest) ProtoMessage()    {}
func (*MonitorRibRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{2}
}

func (m *MonitorRibRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MonitorRibRequest.Unmarshal(m, b)
}
func (m *MonitorRibRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MonitorRibRequest.Marshal(b, m, deterministic)
}
func (m *MonitorRibRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MonitorRibRequest.Merge(m, src)
}
func (m *MonitorRibRequest) XXX_Size() int {
	return xxx_messageInfo_MonitorRibRequest.Size(m)
}
func (m *MonitorRibRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MonitorRibRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MonitorRibRequest proto.InternalMessageInfo

func (m *MonitorRibRequest) GetRt() string {
	if m != nil {
		return m.Rt
	}
	return ""
}

func (m *MonitorRibRequest) GetNId() uint32 {
	if m != nil {
		return m.NId
	}
	return 0
}

type SyncRibRequest struct {
	Rt                   string   `protobuf:"bytes,1,opt,name=rt,proto3" json:"rt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SyncRibRequest) Reset()         { *m = SyncRibRequest{} }
func (m *SyncRibRequest) String() string { return proto.CompactTextString(m) }
func (*SyncRibRequest) ProtoMessage()    {}
func (*SyncRibRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{3}
}

func (m *SyncRibRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SyncRibRequest.Unmarshal(m, b)
}
func (m *SyncRibRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SyncRibRequest.Marshal(b, m, deterministic)
}
func (m *SyncRibRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncRibRequest.Merge(m, src)
}
func (m *SyncRibRequest) XXX_Size() int {
	return xxx_messageInfo_SyncRibRequest.Size(m)
}
func (m *SyncRibRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncRibRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SyncRibRequest proto.InternalMessageInfo

func (m *SyncRibRequest) GetRt() string {
	if m != nil {
		return m.Rt
	}
	return ""
}

type SyncRibReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SyncRibReply) Reset()         { *m = SyncRibReply{} }
func (m *SyncRibReply) String() string { return proto.CompactTextString(m) }
func (*SyncRibReply) ProtoMessage()    {}
func (*SyncRibReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{4}
}

func (m *SyncRibReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SyncRibReply.Unmarshal(m, b)
}
func (m *SyncRibReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SyncRibReply.Marshal(b, m, deterministic)
}
func (m *SyncRibReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncRibReply.Merge(m, src)
}
func (m *SyncRibReply) XXX_Size() int {
	return xxx_messageInfo_SyncRibReply.Size(m)
}
func (m *SyncRibReply) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncRibReply.DiscardUnknown(m)
}

var xxx_messageInfo_SyncRibReply proto.InternalMessageInfo

type GetNexthopsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetNexthopsRequest) Reset()         { *m = GetNexthopsRequest{} }
func (m *GetNexthopsRequest) String() string { return proto.CompactTextString(m) }
func (*GetNexthopsRequest) ProtoMessage()    {}
func (*GetNexthopsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{5}
}

func (m *GetNexthopsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetNexthopsRequest.Unmarshal(m, b)
}
func (m *GetNexthopsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetNexthopsRequest.Marshal(b, m, deterministic)
}
func (m *GetNexthopsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNexthopsRequest.Merge(m, src)
}
func (m *GetNexthopsRequest) XXX_Size() int {
	return xxx_messageInfo_GetNexthopsRequest.Size(m)
}
func (m *GetNexthopsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNexthopsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetNexthopsRequest proto.InternalMessageInfo

type Nexthop struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Rt                   string   `protobuf:"bytes,2,opt,name=rt,proto3" json:"rt,omitempty"`
	Addr                 string   `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
	SourceId             string   `protobuf:"bytes,4,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Nexthop) Reset()         { *m = Nexthop{} }
func (m *Nexthop) String() string { return proto.CompactTextString(m) }
func (*Nexthop) ProtoMessage()    {}
func (*Nexthop) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{6}
}

func (m *Nexthop) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Nexthop.Unmarshal(m, b)
}
func (m *Nexthop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Nexthop.Marshal(b, m, deterministic)
}
func (m *Nexthop) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Nexthop.Merge(m, src)
}
func (m *Nexthop) XXX_Size() int {
	return xxx_messageInfo_Nexthop.Size(m)
}
func (m *Nexthop) XXX_DiscardUnknown() {
	xxx_messageInfo_Nexthop.DiscardUnknown(m)
}

var xxx_messageInfo_Nexthop proto.InternalMessageInfo

func (m *Nexthop) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *Nexthop) GetRt() string {
	if m != nil {
		return m.Rt
	}
	return ""
}

func (m *Nexthop) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *Nexthop) GetSourceId() string {
	if m != nil {
		return m.SourceId
	}
	return ""
}

type GetRicsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetRicsRequest) Reset()         { *m = GetRicsRequest{} }
func (m *GetRicsRequest) String() string { return proto.CompactTextString(m) }
func (*GetRicsRequest) ProtoMessage()    {}
func (*GetRicsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{7}
}

func (m *GetRicsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetRicsRequest.Unmarshal(m, b)
}
func (m *GetRicsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetRicsRequest.Marshal(b, m, deterministic)
}
func (m *GetRicsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRicsRequest.Merge(m, src)
}
func (m *GetRicsRequest) XXX_Size() int {
	return xxx_messageInfo_GetRicsRequest.Size(m)
}
func (m *GetRicsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRicsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetRicsRequest proto.InternalMessageInfo

type RicEntry struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	NId                  uint32   `protobuf:"varint,2,opt,name=n_id,json=nId,proto3" json:"n_id,omitempty"`
	Rt                   string   `protobuf:"bytes,3,opt,name=rt,proto3" json:"rt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RicEntry) Reset()         { *m = RicEntry{} }
func (m *RicEntry) String() string { return proto.CompactTextString(m) }
func (*RicEntry) ProtoMessage()    {}
func (*RicEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{8}
}

func (m *RicEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RicEntry.Unmarshal(m, b)
}
func (m *RicEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RicEntry.Marshal(b, m, deterministic)
}
func (m *RicEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RicEntry.Merge(m, src)
}
func (m *RicEntry) XXX_Size() int {
	return xxx_messageInfo_RicEntry.Size(m)
}
func (m *RicEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_RicEntry.DiscardUnknown(m)
}

var xxx_messageInfo_RicEntry proto.InternalMessageInfo

func (m *RicEntry) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *RicEntry) GetNId() uint32 {
	if m != nil {
		return m.NId
	}
	return 0
}

func (m *RicEntry) GetRt() string {
	if m != nil {
		return m.Rt
	}
	return ""
}

type GetIPMapRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetIPMapRequest) Reset()         { *m = GetIPMapRequest{} }
func (m *GetIPMapRequest) String() string { return proto.CompactTextString(m) }
func (*GetIPMapRequest) ProtoMessage()    {}
func (*GetIPMapRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{9}
}

func (m *GetIPMapRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetIPMapRequest.Unmarshal(m, b)
}
func (m *GetIPMapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetIPMapRequest.Marshal(b, m, deterministic)
}
func (m *GetIPMapRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetIPMapRequest.Merge(m, src)
}
func (m *GetIPMapRequest) XXX_Size() int {
	return xxx_messageInfo_GetIPMapRequest.Size(m)
}
func (m *GetIPMapRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetIPMapRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetIPMapRequest proto.InternalMessageInfo

type IPMapEntry struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IPMapEntry) Reset()         { *m = IPMapEntry{} }
func (m *IPMapEntry) String() string { return proto.CompactTextString(m) }
func (*IPMapEntry) ProtoMessage()    {}
func (*IPMapEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_8f0b45d31dc642a7, []int{10}
}

func (m *IPMapEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IPMapEntry.Unmarshal(m, b)
}
func (m *IPMapEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IPMapEntry.Marshal(b, m, deterministic)
}
func (m *IPMapEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPMapEntry.Merge(m, src)
}
func (m *IPMapEntry) XXX_Size() int {
	return xxx_messageInfo_IPMapEntry.Size(m)
}
func (m *IPMapEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_IPMapEntry.DiscardUnknown(m)
}

var xxx_messageInfo_IPMapEntry proto.InternalMessageInfo

func (m *IPMapEntry) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *IPMapEntry) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func init() {
	proto.RegisterType((*RibUpdate)(nil), "ribsapi.RibUpdate")
	proto.RegisterType((*ModRibReply)(nil), "ribsapi.ModRibReply")
	proto.RegisterType((*MonitorRibRequest)(nil), "ribsapi.MonitorRibRequest")
	proto.RegisterType((*SyncRibRequest)(nil), "ribsapi.SyncRibRequest")
	proto.RegisterType((*SyncRibReply)(nil), "ribsapi.SyncRibReply")
	proto.RegisterType((*GetNexthopsRequest)(nil), "ribsapi.GetNexthopsRequest")
	proto.RegisterType((*Nexthop)(nil), "ribsapi.Nexthop")
	proto.RegisterType((*GetRicsRequest)(nil), "ribsapi.GetRicsRequest")
	proto.RegisterType((*RicEntry)(nil), "ribsapi.RicEntry")
	proto.RegisterType((*GetIPMapRequest)(nil), "ribsapi.GetIPMapRequest")
	proto.RegisterType((*IPMapEntry)(nil), "ribsapi.IPMapEntry")
}

func init() { proto.RegisterFile("ribsapi.proto", fileDescriptor_8f0b45d31dc642a7) }

var fileDescriptor_8f0b45d31dc642a7 = []byte{
	// 417 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x93, 0xcf, 0x6f, 0xd3, 0x30,
	0x14, 0xc7, 0x97, 0xb6, 0x2c, 0xeb, 0xeb, 0x1a, 0x9a, 0x47, 0x11, 0x51, 0x76, 0xa9, 0x7c, 0xda,
	0x69, 0xa0, 0x31, 0x21, 0x21, 0x0e, 0x8c, 0x21, 0x54, 0xe5, 0x10, 0x84, 0x3c, 0x71, 0x43, 0x42,
	0xf9, 0x61, 0x69, 0x16, 0x53, 0x6c, 0x1c, 0x17, 0x91, 0x7f, 0x8f, 0x23, 0x7f, 0x15, 0x8a, 0xe3,
	0xb9, 0x1e, 0xd9, 0x6e, 0x7e, 0xbf, 0xbe, 0xef, 0x7d, 0xf5, 0x91, 0x61, 0xa9, 0x78, 0xd9, 0x16,
	0x92, 0x9f, 0x49, 0x25, 0xb4, 0xc0, 0xd0, 0x86, 0xe4, 0x25, 0xcc, 0x29, 0x2f, 0xbf, 0xca, 0xba,
	0xd0, 0x0c, 0x23, 0x98, 0x28, 0x9d, 0x04, 0x9b, 0xe0, 0x74, 0x4e, 0x27, 0x4a, 0x23, 0xc2, 0x4c,
	0x16, 0xfa, 0x26, 0x99, 0x6c, 0x82, 0xd3, 0x63, 0x6a, 0xde, 0x64, 0x09, 0x8b, 0x5c, 0xd4, 0x94,
	0x97, 0x94, 0xc9, 0xdb, 0x8e, 0xbc, 0x81, 0x38, 0x17, 0x0d, 0xd7, 0x42, 0x99, 0xd4, 0xcf, 0x1d,
	0x6b, 0xf5, 0x48, 0x27, 0x86, 0x59, 0xf3, 0x9d, 0xd7, 0x46, 0x67, 0x49, 0xa7, 0x4d, 0x56, 0x93,
	0x0d, 0x44, 0xd7, 0x5d, 0x53, 0x3d, 0x3e, 0x44, 0x22, 0x38, 0x76, 0x1d, 0xfd, 0xa6, 0x35, 0xe0,
	0x96, 0xe9, 0xcf, 0xec, 0xb7, 0xbe, 0x11, 0xb2, 0xb5, 0x53, 0xe4, 0x1b, 0x84, 0x36, 0x85, 0x2b,
	0x98, 0xfe, 0x60, 0x9d, 0x55, 0xe8, 0x9f, 0x56, 0x72, 0xe2, 0xfb, 0x29, 0xea, 0x5a, 0x25, 0x53,
	0x93, 0x31, 0x6f, 0x3c, 0x81, 0x79, 0x2b, 0x76, 0xaa, 0x62, 0xfd, 0x81, 0x33, 0x53, 0x38, 0x1a,
	0x12, 0x59, 0x4d, 0x56, 0x10, 0x6d, 0x99, 0xa6, 0xbc, 0x72, 0xfb, 0xde, 0xc3, 0x11, 0xe5, 0xd5,
	0xa7, 0x46, 0xab, 0xee, 0x81, 0x85, 0x63, 0xa3, 0xf6, 0x86, 0xa9, 0xb3, 0x15, 0xc3, 0xd3, 0x2d,
	0xd3, 0xd9, 0x97, 0xbc, 0x90, 0x77, 0x9a, 0x17, 0x00, 0x26, 0x7e, 0x4c, 0x75, 0x0d, 0x4f, 0x7e,
	0x15, 0xb7, 0x3b, 0x66, 0x9d, 0x0c, 0xc1, 0xf9, 0x9f, 0x00, 0x16, 0x34, 0xbb, 0xba, 0xfe, 0x28,
	0x14, 0xfb, 0x20, 0x39, 0x5e, 0xc0, 0xe1, 0x00, 0x06, 0xf1, 0xec, 0x0e, 0xb6, 0x43, 0x9b, 0xae,
	0x5d, 0xce, 0xa7, 0x77, 0x80, 0x97, 0x00, 0x7b, 0x7e, 0x98, 0x7a, 0x5d, 0xff, 0x41, 0x4d, 0x1f,
	0x50, 0x25, 0x07, 0xaf, 0x02, 0x7c, 0x07, 0xa1, 0xe5, 0x84, 0x2f, 0x5c, 0xcb, 0x7d, 0xb6, 0xe9,
	0xf3, 0x71, 0xc1, 0xac, 0x3f, 0xff, 0x1b, 0x40, 0xd8, 0x9b, 0xe8, 0x0d, 0x5c, 0xc2, 0xc2, 0x03,
	0x8c, 0x27, 0x6e, 0x66, 0x8c, 0x3d, 0x5d, 0xb9, 0xa2, 0xad, 0x98, 0x53, 0xde, 0x42, 0x68, 0x71,
	0x79, 0xa7, 0xdc, 0x07, 0x98, 0xc6, 0x9e, 0x8d, 0x81, 0xa3, 0x19, 0xbd, 0x82, 0xe5, 0x7e, 0x4d,
	0x5e, 0x48, 0x4c, 0x7c, 0x01, 0x1f, 0x57, 0xfa, 0xcc, 0x55, 0xf6, 0xd4, 0x7a, 0x8d, 0xf2, 0xd0,
	0xfc, 0xad, 0xd7, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x27, 0x7d, 0x66, 0xe5, 0x6c, 0x03, 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

// RIBSCoreApiClient is the client API for RIBSCoreApi service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RIBSCoreApiClient interface {
	ModRib(ctx context.Context, in *RibUpdate, opts ...grpc.CallOption) (*ModRibReply, error)
	MonitorRib(ctx context.Context, in *MonitorRibRequest, opts ...grpc.CallOption) (RIBSCoreApi_MonitorRibClient, error)
	SyncRib(ctx context.Context, in *SyncRibRequest, opts ...grpc.CallOption) (*SyncRibReply, error)
}

type rIBSCoreApiClient struct {
	cc *grpc.ClientConn
}

func NewRIBSCoreApiClient(cc *grpc.ClientConn) RIBSCoreApiClient {
	return &rIBSCoreApiClient{cc}
}

func (c *rIBSCoreApiClient) ModRib(ctx context.Context, in *RibUpdate, opts ...grpc.CallOption) (*ModRibReply, error) {
	out := new(ModRibReply)
	err := c.cc.Invoke(ctx, "/ribsapi.RIBSCoreApi/ModRib", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rIBSCoreApiClient) MonitorRib(ctx context.Context, in *MonitorRibRequest, opts ...grpc.CallOption) (RIBSCoreApi_MonitorRibClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RIBSCoreApi_serviceDesc.Streams[0], "/ribsapi.RIBSCoreApi/MonitorRib", opts...)
	if err != nil {
		return nil, err
	}
	x := &rIBSCoreApiMonitorRibClient{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 RIBSCoreApi_MonitorRibClient interface {
	Recv() (*RibUpdate, error)
	grpc.ClientStream
}

type rIBSCoreApiMonitorRibClient struct {
	grpc.ClientStream
}

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

func (c *rIBSCoreApiClient) SyncRib(ctx context.Context, in *SyncRibRequest, opts ...grpc.CallOption) (*SyncRibReply, error) {
	out := new(SyncRibReply)
	err := c.cc.Invoke(ctx, "/ribsapi.RIBSCoreApi/SyncRib", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RIBSCoreApiServer is the server API for RIBSCoreApi service.
type RIBSCoreApiServer interface {
	ModRib(context.Context, *RibUpdate) (*ModRibReply, error)
	MonitorRib(*MonitorRibRequest, RIBSCoreApi_MonitorRibServer) error
	SyncRib(context.Context, *SyncRibRequest) (*SyncRibReply, error)
}

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

func (*UnimplementedRIBSCoreApiServer) ModRib(ctx context.Context, req *RibUpdate) (*ModRibReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModRib not implemented")
}
func (*UnimplementedRIBSCoreApiServer) MonitorRib(req *MonitorRibRequest, srv RIBSCoreApi_MonitorRibServer) error {
	return status.Errorf(codes.Unimplemented, "method MonitorRib not implemented")
}
func (*UnimplementedRIBSCoreApiServer) SyncRib(ctx context.Context, req *SyncRibRequest) (*SyncRibReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncRib not implemented")
}

func RegisterRIBSCoreApiServer(s *grpc.Server, srv RIBSCoreApiServer) {
	s.RegisterService(&_RIBSCoreApi_serviceDesc, srv)
}

func _RIBSCoreApi_ModRib_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RibUpdate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RIBSCoreApiServer).ModRib(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ribsapi.RIBSCoreApi/ModRib",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RIBSCoreApiServer).ModRib(ctx, req.(*RibUpdate))
	}
	return interceptor(ctx, in, info, handler)
}

func _RIBSCoreApi_MonitorRib_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(MonitorRibRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RIBSCoreApiServer).MonitorRib(m, &rIBSCoreApiMonitorRibServer{stream})
}

type RIBSCoreApi_MonitorRibServer interface {
	Send(*RibUpdate) error
	grpc.ServerStream
}

type rIBSCoreApiMonitorRibServer struct {
	grpc.ServerStream
}

func (x *rIBSCoreApiMonitorRibServer) Send(m *RibUpdate) error {
	return x.ServerStream.SendMsg(m)
}

func _RIBSCoreApi_SyncRib_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncRibRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RIBSCoreApiServer).SyncRib(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ribsapi.RIBSCoreApi/SyncRib",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RIBSCoreApiServer).SyncRib(ctx, req.(*SyncRibRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _RIBSCoreApi_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ribsapi.RIBSCoreApi",
	HandlerType: (*RIBSCoreApiServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ModRib",
			Handler:    _RIBSCoreApi_ModRib_Handler,
		},
		{
			MethodName: "SyncRib",
			Handler:    _RIBSCoreApi_SyncRib_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "MonitorRib",
			Handler:       _RIBSCoreApi_MonitorRib_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ribsapi.proto",
}

// RIBSApiClient is the client API for RIBSApi service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RIBSApiClient interface {
	GetNexthops(ctx context.Context, in *GetNexthopsRequest, opts ...grpc.CallOption) (RIBSApi_GetNexthopsClient, error)
	GetRics(ctx context.Context, in *GetRicsRequest, opts ...grpc.CallOption) (RIBSApi_GetRicsClient, error)
	GetNexthopMap(ctx context.Context, in *GetIPMapRequest, opts ...grpc.CallOption) (RIBSApi_GetNexthopMapClient, error)
}

type rIBSApiClient struct {
	cc *grpc.ClientConn
}

func NewRIBSApiClient(cc *grpc.ClientConn) RIBSApiClient {
	return &rIBSApiClient{cc}
}

func (c *rIBSApiClient) GetNexthops(ctx context.Context, in *GetNexthopsRequest, opts ...grpc.CallOption) (RIBSApi_GetNexthopsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RIBSApi_serviceDesc.Streams[0], "/ribsapi.RIBSApi/GetNexthops", opts...)
	if err != nil {
		return nil, err
	}
	x := &rIBSApiGetNexthopsClient{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 RIBSApi_GetNexthopsClient interface {
	Recv() (*Nexthop, error)
	grpc.ClientStream
}

type rIBSApiGetNexthopsClient struct {
	grpc.ClientStream
}

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

func (c *rIBSApiClient) GetRics(ctx context.Context, in *GetRicsRequest, opts ...grpc.CallOption) (RIBSApi_GetRicsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RIBSApi_serviceDesc.Streams[1], "/ribsapi.RIBSApi/GetRics", opts...)
	if err != nil {
		return nil, err
	}
	x := &rIBSApiGetRicsClient{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 RIBSApi_GetRicsClient interface {
	Recv() (*RicEntry, error)
	grpc.ClientStream
}

type rIBSApiGetRicsClient struct {
	grpc.ClientStream
}

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

func (c *rIBSApiClient) GetNexthopMap(ctx context.Context, in *GetIPMapRequest, opts ...grpc.CallOption) (RIBSApi_GetNexthopMapClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RIBSApi_serviceDesc.Streams[2], "/ribsapi.RIBSApi/GetNexthopMap", opts...)
	if err != nil {
		return nil, err
	}
	x := &rIBSApiGetNexthopMapClient{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 RIBSApi_GetNexthopMapClient interface {
	Recv() (*IPMapEntry, error)
	grpc.ClientStream
}

type rIBSApiGetNexthopMapClient struct {
	grpc.ClientStream
}

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

// RIBSApiServer is the server API for RIBSApi service.
type RIBSApiServer interface {
	GetNexthops(*GetNexthopsRequest, RIBSApi_GetNexthopsServer) error
	GetRics(*GetRicsRequest, RIBSApi_GetRicsServer) error
	GetNexthopMap(*GetIPMapRequest, RIBSApi_GetNexthopMapServer) error
}

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

func (*UnimplementedRIBSApiServer) GetNexthops(req *GetNexthopsRequest, srv RIBSApi_GetNexthopsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetNexthops not implemented")
}
func (*UnimplementedRIBSApiServer) GetRics(req *GetRicsRequest, srv RIBSApi_GetRicsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetRics not implemented")
}
func (*UnimplementedRIBSApiServer) GetNexthopMap(req *GetIPMapRequest, srv RIBSApi_GetNexthopMapServer) error {
	return status.Errorf(codes.Unimplemented, "method GetNexthopMap not implemented")
}

func RegisterRIBSApiServer(s *grpc.Server, srv RIBSApiServer) {
	s.RegisterService(&_RIBSApi_serviceDesc, srv)
}

func _RIBSApi_GetNexthops_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetNexthopsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RIBSApiServer).GetNexthops(m, &rIBSApiGetNexthopsServer{stream})
}

type RIBSApi_GetNexthopsServer interface {
	Send(*Nexthop) error
	grpc.ServerStream
}

type rIBSApiGetNexthopsServer struct {
	grpc.ServerStream
}

func (x *rIBSApiGetNexthopsServer) Send(m *Nexthop) error {
	return x.ServerStream.SendMsg(m)
}

func _RIBSApi_GetRics_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetRicsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RIBSApiServer).GetRics(m, &rIBSApiGetRicsServer{stream})
}

type RIBSApi_GetRicsServer interface {
	Send(*RicEntry) error
	grpc.ServerStream
}

type rIBSApiGetRicsServer struct {
	grpc.ServerStream
}

func (x *rIBSApiGetRicsServer) Send(m *RicEntry) error {
	return x.ServerStream.SendMsg(m)
}

func _RIBSApi_GetNexthopMap_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetIPMapRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RIBSApiServer).GetNexthopMap(m, &rIBSApiGetNexthopMapServer{stream})
}

type RIBSApi_GetNexthopMapServer interface {
	Send(*IPMapEntry) error
	grpc.ServerStream
}

type rIBSApiGetNexthopMapServer struct {
	grpc.ServerStream
}

func (x *rIBSApiGetNexthopMapServer) Send(m *IPMapEntry) error {
	return x.ServerStream.SendMsg(m)
}

var _RIBSApi_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ribsapi.RIBSApi",
	HandlerType: (*RIBSApiServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetNexthops",
			Handler:       _RIBSApi_GetNexthops_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetRics",
			Handler:       _RIBSApi_GetRics_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetNexthopMap",
			Handler:       _RIBSApi_GetNexthopMap_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ribsapi.proto",
}
