github.com/tickoalcantara12/micro/v3@v3.0.0-20221007104245-9d75b9bcbab9/proto/router/router.pb.go

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

package router

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	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

// EventType defines the type of event
type EventType int32

const (
	EventType_Create EventType = 0
	EventType_Delete EventType = 1
	EventType_Update EventType = 2
)

var EventType_name = map[int32]string{
	0: "Create",
	1: "Delete",
	2: "Update",
}

var EventType_value = map[string]int32{
	"Create": 0,
	"Delete": 1,
	"Update": 2,
}

func (x EventType) String() string {
	return proto.EnumName(EventType_name, int32(x))
}

func (EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7214bc1619ffe283, []int{0}
}

// Empty request
type ReadRequest struct {
	Service              string   `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReadRequest proto.InternalMessageInfo

func (m *ReadRequest) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

// Empty response
type ReadResponse struct {
	Routes               []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReadResponse proto.InternalMessageInfo

func (m *ReadResponse) GetRoutes() []*Route {
	if m != nil {
		return m.Routes
	}
	return nil
}

// LookupRequest is made to Lookup
type LookupRequest struct {
	Service              string         `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	Options              *LookupOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_LookupRequest proto.InternalMessageInfo

func (m *LookupRequest) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *LookupRequest) GetOptions() *LookupOptions {
	if m != nil {
		return m.Options
	}
	return nil
}

// LookupResponse is returned by Lookup
type LookupResponse struct {
	Routes               []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LookupResponse proto.InternalMessageInfo

func (m *LookupResponse) GetRoutes() []*Route {
	if m != nil {
		return m.Routes
	}
	return nil
}

// WatchRequest is made to Watch Router
type WatchRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_WatchRequest proto.InternalMessageInfo

// CreateResponse is returned by Create
type CreateResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CreateResponse proto.InternalMessageInfo

// DeleteResponse is returned by Delete
type DeleteResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo

// UpdateResponse is returned by Update
type UpdateResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo

// Event is routing table event
type Event struct {
	// the unique event id
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// type of event
	Type EventType `protobuf:"varint,2,opt,name=type,proto3,enum=router.EventType" json:"type,omitempty"`
	// unix timestamp of event
	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// service route
	Route                *Route   `protobuf:"bytes,4,opt,name=route,proto3" json:"route,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Event) GetType() EventType {
	if m != nil {
		return m.Type
	}
	return EventType_Create
}

func (m *Event) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *Event) GetRoute() *Route {
	if m != nil {
		return m.Route
	}
	return nil
}

// LookupOptions are passed in a LookupRequest
type LookupOptions struct {
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Gateway              string   `protobuf:"bytes,2,opt,name=gateway,proto3" json:"gateway,omitempty"`
	Network              string   `protobuf:"bytes,3,opt,name=network,proto3" json:"network,omitempty"`
	Router               string   `protobuf:"bytes,4,opt,name=router,proto3" json:"router,omitempty"`
	Link                 string   `protobuf:"bytes,5,opt,name=link,proto3" json:"link,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LookupOptions proto.InternalMessageInfo

func (m *LookupOptions) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *LookupOptions) GetGateway() string {
	if m != nil {
		return m.Gateway
	}
	return ""
}

func (m *LookupOptions) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *LookupOptions) GetRouter() string {
	if m != nil {
		return m.Router
	}
	return ""
}

func (m *LookupOptions) GetLink() string {
	if m != nil {
		return m.Link
	}
	return ""
}

// Route is a service route
type Route struct {
	// service for the route
	Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// the address that advertise this route
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	// gateway as the next hop
	Gateway string `protobuf:"bytes,3,opt,name=gateway,proto3" json:"gateway,omitempty"`
	// the network for this destination
	Network string `protobuf:"bytes,4,opt,name=network,proto3" json:"network,omitempty"`
	// router if the router id
	Router string `protobuf:"bytes,5,opt,name=router,proto3" json:"router,omitempty"`
	// the network link
	Link string `protobuf:"bytes,6,opt,name=link,proto3" json:"link,omitempty"`
	// the metric / score of this route
	Metric int64 `protobuf:"varint,7,opt,name=metric,proto3" json:"metric,omitempty"`
	// metadata for the route
	Metadata             map[string]string `protobuf:"bytes,8,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_Route proto.InternalMessageInfo

func (m *Route) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *Route) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *Route) GetGateway() string {
	if m != nil {
		return m.Gateway
	}
	return ""
}

func (m *Route) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *Route) GetRouter() string {
	if m != nil {
		return m.Router
	}
	return ""
}

func (m *Route) GetLink() string {
	if m != nil {
		return m.Link
	}
	return ""
}

func (m *Route) GetMetric() int64 {
	if m != nil {
		return m.Metric
	}
	return 0
}

func (m *Route) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func init() {
	proto.RegisterEnum("router.EventType", EventType_name, EventType_value)
	proto.RegisterType((*ReadRequest)(nil), "router.ReadRequest")
	proto.RegisterType((*ReadResponse)(nil), "router.ReadResponse")
	proto.RegisterType((*LookupRequest)(nil), "router.LookupRequest")
	proto.RegisterType((*LookupResponse)(nil), "router.LookupResponse")
	proto.RegisterType((*WatchRequest)(nil), "router.WatchRequest")
	proto.RegisterType((*CreateResponse)(nil), "router.CreateResponse")
	proto.RegisterType((*DeleteResponse)(nil), "router.DeleteResponse")
	proto.RegisterType((*UpdateResponse)(nil), "router.UpdateResponse")
	proto.RegisterType((*Event)(nil), "router.Event")
	proto.RegisterType((*LookupOptions)(nil), "router.LookupOptions")
	proto.RegisterType((*Route)(nil), "router.Route")
	proto.RegisterMapType((map[string]string)(nil), "router.Route.MetadataEntry")
}

func init() { proto.RegisterFile("router/router.proto", fileDescriptor_7214bc1619ffe283) }

var fileDescriptor_7214bc1619ffe283 = []byte{
	// 589 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcb, 0x6e, 0xd3, 0x4c,
	0x14, 0x8e, 0x9d, 0xd8, 0xad, 0x4f, 0x9b, 0x28, 0xff, 0xb4, 0x7f, 0x65, 0x05, 0x16, 0x91, 0x51,
	0x45, 0x84, 0x44, 0x5c, 0x12, 0xa1, 0x02, 0xdd, 0x01, 0xdd, 0x81, 0x90, 0x46, 0x45, 0x48, 0xdd,
	0x4d, 0xe2, 0xa3, 0xd6, 0x4a, 0x7c, 0x61, 0x3c, 0x4e, 0x95, 0x25, 0x4b, 0x1e, 0x85, 0x07, 0xe2,
	0x7d, 0x90, 0xe7, 0x92, 0xc4, 0x16, 0x01, 0xb1, 0xc9, 0xcc, 0xb9, 0xe6, 0x3b, 0x9f, 0xbf, 0x33,
	0x70, 0xc2, 0xb3, 0x52, 0x20, 0x0f, 0xd5, 0x31, 0xce, 0x79, 0x26, 0x32, 0xe2, 0x2a, 0x2b, 0x78,
	0x0a, 0x47, 0x14, 0x59, 0x44, 0xf1, 0x6b, 0x89, 0x85, 0x20, 0x3e, 0x1c, 0x14, 0xc8, 0x57, 0xf1,
	0x1c, 0x7d, 0x6b, 0x68, 0x8d, 0x3c, 0x6a, 0xcc, 0xe0, 0x25, 0x1c, 0xab, 0xc4, 0x22, 0xcf, 0xd2,
	0x02, 0xc9, 0x39, 0xa8, 0x16, 0x85, 0x6f, 0x0d, 0xdb, 0xa3, 0xa3, 0x49, 0x77, 0xac, 0xfb, 0xd3,
	0xea, 0xa0, 0x3a, 0x18, 0xdc, 0x42, 0xf7, 0x43, 0x96, 0x2d, 0xca, 0xfc, 0xaf, 0xff, 0x40, 0x42,
	0x38, 0xc8, 0x72, 0x11, 0x67, 0x69, 0xe1, 0xdb, 0x43, 0x6b, 0x74, 0x34, 0xf9, 0xdf, 0xb4, 0x54,
	0x1d, 0x3e, 0xa9, 0x20, 0x35, 0x59, 0xc1, 0x25, 0xf4, 0x4c, 0xef, 0x7f, 0x03, 0xd5, 0x83, 0xe3,
	0x2f, 0x4c, 0xcc, 0xef, 0x35, 0xa6, 0xa0, 0x0f, 0xbd, 0x77, 0x1c, 0x99, 0x40, 0xd3, 0xa8, 0xf2,
	0xbc, 0xc7, 0x25, 0xd6, 0x3d, 0x9f, 0xf3, 0x68, 0x37, 0xe7, 0x9b, 0x05, 0xce, 0xf5, 0x0a, 0x53,
	0x41, 0x7a, 0x60, 0xc7, 0x91, 0x1e, 0xc7, 0x8e, 0x23, 0x72, 0x0e, 0x1d, 0xb1, 0xce, 0x51, 0x8e,
	0xd1, 0x9b, 0xfc, 0x67, 0x40, 0xc8, 0xe4, 0x9b, 0x75, 0x8e, 0x54, 0x86, 0xc9, 0x63, 0xf0, 0x44,
	0x9c, 0x60, 0x21, 0x58, 0x92, 0xfb, 0xed, 0xa1, 0x35, 0x6a, 0xd3, 0xad, 0x83, 0x3c, 0x01, 0x47,
	0xd6, 0xf9, 0x1d, 0x49, 0x46, 0x63, 0x14, 0x15, 0x0b, 0xbe, 0x5b, 0x86, 0x5f, 0xcd, 0x4e, 0xc5,
	0x2f, 0x8b, 0x22, 0x8e, 0x45, 0x61, 0xf8, 0xd5, 0x66, 0x15, 0xb9, 0x63, 0x02, 0x1f, 0xd8, 0x5a,
	0x02, 0xf3, 0xa8, 0x31, 0xab, 0x48, 0x8a, 0xe2, 0x21, 0xe3, 0x0b, 0x09, 0xc3, 0xa3, 0xc6, 0x24,
	0x67, 0x9a, 0x50, 0x2e, 0x51, 0x78, 0x9a, 0x41, 0x4e, 0x08, 0x74, 0x96, 0x71, 0xba, 0xf0, 0x1d,
	0xe9, 0x95, 0xf7, 0xe0, 0x87, 0x0d, 0x8e, 0x04, 0xf7, 0x87, 0x6f, 0xbc, 0x83, 0xce, 0xde, 0x8b,
	0xae, 0xbd, 0x17, 0x5d, 0x67, 0x1f, 0x3a, 0xe7, 0xb7, 0xe8, 0xdc, 0x2d, 0xba, 0x2a, 0x37, 0x41,
	0xc1, 0xe3, 0xb9, 0x7f, 0x20, 0x99, 0xd6, 0x16, 0xb9, 0x84, 0xc3, 0x04, 0x05, 0x8b, 0x98, 0x60,
	0xfe, 0xa1, 0x14, 0xcd, 0xa3, 0x1a, 0xd3, 0xe3, 0x8f, 0x3a, 0x7a, 0x9d, 0x0a, 0xbe, 0xa6, 0x9b,
	0xe4, 0xc1, 0x15, 0x74, 0x6b, 0x21, 0xd2, 0x87, 0xf6, 0x02, 0xd7, 0x7a, 0xe2, 0xea, 0x4a, 0x4e,
	0xc1, 0x59, 0xb1, 0x65, 0x89, 0x7a, 0x56, 0x65, 0xbc, 0xb1, 0x5f, 0x59, 0xcf, 0x42, 0xf0, 0x36,
	0x6a, 0x20, 0x00, 0xae, 0x92, 0x5f, 0xbf, 0x55, 0xdd, 0x95, 0xf0, 0xfa, 0x56, 0x75, 0x57, 0x92,
	0xeb, 0xdb, 0x93, 0x12, 0x5c, 0xaa, 0x86, 0x7b, 0x0d, 0xae, 0xfa, 0xe2, 0xa4, 0xb1, 0x1f, 0x5a,
	0xcd, 0x83, 0xb3, 0xa6, 0x5b, 0xeb, 0xb5, 0x45, 0x2e, 0xc0, 0x91, 0xba, 0x27, 0xa7, 0x26, 0x65,
	0x77, 0x0d, 0x06, 0xdd, 0x9a, 0x50, 0x83, 0xd6, 0x85, 0x35, 0xf9, 0x69, 0x81, 0x73, 0xc3, 0x66,
	0x4b, 0x24, 0x2f, 0x0c, 0x48, 0x52, 0x57, 0xe2, 0xf6, 0xef, 0x1a, 0x2b, 0xd4, 0xaa, 0x4a, 0xd4,
	0x2c, 0x7b, 0x4b, 0x1a, 0x3b, 0x26, 0x4b, 0xd4, 0xc8, 0x7b, 0x4b, 0x1a, 0x4b, 0xd8, 0x22, 0x53,
	0xe8, 0x54, 0x0f, 0x13, 0x39, 0xd9, 0x14, 0x6c, 0xdf, 0xb3, 0xc1, 0x69, 0xdd, 0x69, 0x8a, 0xde,
	0x86, 0xb7, 0xcf, 0xef, 0x62, 0x71, 0x5f, 0xce, 0xc6, 0xf3, 0x2c, 0x09, 0x93, 0x78, 0xce, 0x33,
	0xfd, 0xbb, 0x9a, 0x86, 0xf2, 0x85, 0xd4, 0xcf, 0xe5, 0x95, 0x3a, 0x66, 0xae, 0x74, 0x4e, 0x7f,
	0x05, 0x00, 0x00, 0xff, 0xff, 0x54, 0xb5, 0x59, 0x40, 0x4d, 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

// RouterClient is the client API for Router service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RouterClient interface {
	Lookup(ctx context.Context, in *LookupRequest, opts ...grpc.CallOption) (*LookupResponse, error)
	Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (Router_WatchClient, error)
}

type routerClient struct {
	cc *grpc.ClientConn
}

func NewRouterClient(cc *grpc.ClientConn) RouterClient {
	return &routerClient{cc}
}

func (c *routerClient) Lookup(ctx context.Context, in *LookupRequest, opts ...grpc.CallOption) (*LookupResponse, error) {
	out := new(LookupResponse)
	err := c.cc.Invoke(ctx, "/router.Router/Lookup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routerClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (Router_WatchClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Router_serviceDesc.Streams[0], "/router.Router/Watch", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerWatchClient{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 Router_WatchClient interface {
	Recv() (*Event, error)
	grpc.ClientStream
}

type routerWatchClient struct {
	grpc.ClientStream
}

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

// RouterServer is the server API for Router service.
type RouterServer interface {
	Lookup(context.Context, *LookupRequest) (*LookupResponse, error)
	Watch(*WatchRequest, Router_WatchServer) error
}

func RegisterRouterServer(s *grpc.Server, srv RouterServer) {
	s.RegisterService(&_Router_serviceDesc, srv)
}

func _Router_Lookup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouterServer).Lookup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.Router/Lookup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterServer).Lookup(ctx, req.(*LookupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Router_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouterServer).Watch(m, &routerWatchServer{stream})
}

type Router_WatchServer interface {
	Send(*Event) error
	grpc.ServerStream
}

type routerWatchServer struct {
	grpc.ServerStream
}

func (x *routerWatchServer) Send(m *Event) error {
	return x.ServerStream.SendMsg(m)
}

var _Router_serviceDesc = grpc.ServiceDesc{
	ServiceName: "router.Router",
	HandlerType: (*RouterServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Lookup",
			Handler:    _Router_Lookup_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Watch",
			Handler:       _Router_Watch_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "router/router.proto",
}

// TableClient is the client API for Table service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TableClient interface {
	Create(ctx context.Context, in *Route, opts ...grpc.CallOption) (*CreateResponse, error)
	Delete(ctx context.Context, in *Route, opts ...grpc.CallOption) (*DeleteResponse, error)
	Update(ctx context.Context, in *Route, opts ...grpc.CallOption) (*UpdateResponse, error)
	Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error)
}

type tableClient struct {
	cc *grpc.ClientConn
}

func NewTableClient(cc *grpc.ClientConn) TableClient {
	return &tableClient{cc}
}

func (c *tableClient) Create(ctx context.Context, in *Route, opts ...grpc.CallOption) (*CreateResponse, error) {
	out := new(CreateResponse)
	err := c.cc.Invoke(ctx, "/router.Table/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tableClient) Delete(ctx context.Context, in *Route, opts ...grpc.CallOption) (*DeleteResponse, error) {
	out := new(DeleteResponse)
	err := c.cc.Invoke(ctx, "/router.Table/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tableClient) Update(ctx context.Context, in *Route, opts ...grpc.CallOption) (*UpdateResponse, error) {
	out := new(UpdateResponse)
	err := c.cc.Invoke(ctx, "/router.Table/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tableClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) {
	out := new(ReadResponse)
	err := c.cc.Invoke(ctx, "/router.Table/Read", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TableServer is the server API for Table service.
type TableServer interface {
	Create(context.Context, *Route) (*CreateResponse, error)
	Delete(context.Context, *Route) (*DeleteResponse, error)
	Update(context.Context, *Route) (*UpdateResponse, error)
	Read(context.Context, *ReadRequest) (*ReadResponse, error)
}

func RegisterTableServer(s *grpc.Server, srv TableServer) {
	s.RegisterService(&_Table_serviceDesc, srv)
}

func _Table_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Route)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TableServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.Table/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TableServer).Create(ctx, req.(*Route))
	}
	return interceptor(ctx, in, info, handler)
}

func _Table_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Route)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TableServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.Table/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TableServer).Delete(ctx, req.(*Route))
	}
	return interceptor(ctx, in, info, handler)
}

func _Table_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Route)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TableServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.Table/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TableServer).Update(ctx, req.(*Route))
	}
	return interceptor(ctx, in, info, handler)
}

func _Table_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TableServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.Table/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TableServer).Read(ctx, req.(*ReadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Table_serviceDesc = grpc.ServiceDesc{
	ServiceName: "router.Table",
	HandlerType: (*TableServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _Table_Create_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _Table_Delete_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _Table_Update_Handler,
		},
		{
			MethodName: "Read",
			Handler:    _Table_Read_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "router/router.proto",
}