netmaker/grpc/flow/flow.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v3.21.12
// source: grpc/flow/flow.proto

package flow

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// *
// Lifecycle stage of a flow event as seen by an netclient.
// A flow produces:
//   - EVENT_START   when conntrack entry is created
//   - EVENT_DESTROY when conntrack entry is removed
type EventType int32

const (
	EventType_EVENT_TYPE_UNSPECIFIED EventType = 0
	EventType_EVENT_START            EventType = 1
	EventType_EVENT_DESTROY          EventType = 2
)

// Enum value maps for EventType.
var (
	EventType_name = map[int32]string{
		0: "EVENT_TYPE_UNSPECIFIED",
		1: "EVENT_START",
		2: "EVENT_DESTROY",
	}
	EventType_value = map[string]int32{
		"EVENT_TYPE_UNSPECIFIED": 0,
		"EVENT_START":            1,
		"EVENT_DESTROY":          2,
	}
)

func (x EventType) Enum() *EventType {
	p := new(EventType)
	*p = x
	return p
}

func (x EventType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (EventType) Descriptor() protoreflect.EnumDescriptor {
	return file_grpc_flow_flow_proto_enumTypes[0].Descriptor()
}

func (EventType) Type() protoreflect.EnumType {
	return &file_grpc_flow_flow_proto_enumTypes[0]
}

func (x EventType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use EventType.Descriptor instead.
func (EventType) EnumDescriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{0}
}

// *
// Identifies what kind of participant an IP belongs to.
type ParticipantType int32

const (
	ParticipantType_PARTICIPANT_UNSPECIFIED  ParticipantType = 0
	ParticipantType_PARTICIPANT_NODE         ParticipantType = 1
	ParticipantType_PARTICIPANT_USER         ParticipantType = 2
	ParticipantType_PARTICIPANT_EXTCLIENT    ParticipantType = 3
	ParticipantType_PARTICIPANT_EGRESS_ROUTE ParticipantType = 4
	ParticipantType_PARTICIPANT_EXTERNAL     ParticipantType = 5 // anything not part of the Netmaker network
)

// Enum value maps for ParticipantType.
var (
	ParticipantType_name = map[int32]string{
		0: "PARTICIPANT_UNSPECIFIED",
		1: "PARTICIPANT_NODE",
		2: "PARTICIPANT_USER",
		3: "PARTICIPANT_EXTCLIENT",
		4: "PARTICIPANT_EGRESS_ROUTE",
		5: "PARTICIPANT_EXTERNAL",
	}
	ParticipantType_value = map[string]int32{
		"PARTICIPANT_UNSPECIFIED":  0,
		"PARTICIPANT_NODE":         1,
		"PARTICIPANT_USER":         2,
		"PARTICIPANT_EXTCLIENT":    3,
		"PARTICIPANT_EGRESS_ROUTE": 4,
		"PARTICIPANT_EXTERNAL":     5,
	}
)

func (x ParticipantType) Enum() *ParticipantType {
	p := new(ParticipantType)
	*p = x
	return p
}

func (x ParticipantType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ParticipantType) Descriptor() protoreflect.EnumDescriptor {
	return file_grpc_flow_flow_proto_enumTypes[1].Descriptor()
}

func (ParticipantType) Type() protoreflect.EnumType {
	return &file_grpc_flow_flow_proto_enumTypes[1]
}

func (x ParticipantType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ParticipantType.Descriptor instead.
func (ParticipantType) EnumDescriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{1}
}

// *
// Direction of the flow relative to the observing node.
type Direction int32

const (
	Direction_DIR_UNSPECIFIED Direction = 0
	Direction_DIR_INGRESS     Direction = 1
	Direction_DIR_EGRESS      Direction = 2
)

// Enum value maps for Direction.
var (
	Direction_name = map[int32]string{
		0: "DIR_UNSPECIFIED",
		1: "DIR_INGRESS",
		2: "DIR_EGRESS",
	}
	Direction_value = map[string]int32{
		"DIR_UNSPECIFIED": 0,
		"DIR_INGRESS":     1,
		"DIR_EGRESS":      2,
	}
)

func (x Direction) Enum() *Direction {
	p := new(Direction)
	*p = x
	return p
}

func (x Direction) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Direction) Descriptor() protoreflect.EnumDescriptor {
	return file_grpc_flow_flow_proto_enumTypes[2].Descriptor()
}

func (Direction) Type() protoreflect.EnumType {
	return &file_grpc_flow_flow_proto_enumTypes[2]
}

func (x Direction) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Direction.Descriptor instead.
func (Direction) EnumDescriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{2}
}

// *
// Fully enriched representation of one endpoint of a flow.
type FlowParticipant struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ip            string                 `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Type          ParticipantType        `protobuf:"varint,2,opt,name=type,proto3,enum=netmaker.flow.ParticipantType" json:"type,omitempty"`
	Id            string                 `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FlowParticipant) Reset() {
	*x = FlowParticipant{}
	mi := &file_grpc_flow_flow_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FlowParticipant) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FlowParticipant) ProtoMessage() {}

func (x *FlowParticipant) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_flow_flow_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FlowParticipant.ProtoReflect.Descriptor instead.
func (*FlowParticipant) Descriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{0}
}

func (x *FlowParticipant) GetIp() string {
	if x != nil {
		return x.Ip
	}
	return ""
}

func (x *FlowParticipant) GetType() ParticipantType {
	if x != nil {
		return x.Type
	}
	return ParticipantType_PARTICIPANT_UNSPECIFIED
}

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

// *
// Flow event generated by netclient.
type FlowEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Flow lifecycle event type (START or DESTROY)
	Type EventType `protobuf:"varint,1,opt,name=type,proto3,enum=netmaker.flow.EventType" json:"type,omitempty"`
	// Stable identity
	FlowId    string `protobuf:"bytes,2,opt,name=flow_id,json=flowId,proto3" json:"flow_id,omitempty"`          // unique per flow
	NetworkId string `protobuf:"bytes,3,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"` // network this flow belongs to
	HostId    string `protobuf:"bytes,4,opt,name=host_id,json=hostId,proto3" json:"host_id,omitempty"`          // node reporting this event
	// L3/L4 metadata
	Protocol  uint32    `protobuf:"varint,5,opt,name=protocol,proto3" json:"protocol,omitempty"`
	SrcPort   uint32    `protobuf:"varint,6,opt,name=src_port,json=srcPort,proto3" json:"src_port,omitempty"`
	DstPort   uint32    `protobuf:"varint,7,opt,name=dst_port,json=dstPort,proto3" json:"dst_port,omitempty"`
	IcmpType  uint32    `protobuf:"varint,8,opt,name=icmp_type,json=icmpType,proto3" json:"icmp_type,omitempty"`
	IcmpCode  uint32    `protobuf:"varint,9,opt,name=icmp_code,json=icmpCode,proto3" json:"icmp_code,omitempty"`
	Direction Direction `protobuf:"varint,10,opt,name=direction,proto3,enum=netmaker.flow.Direction" json:"direction,omitempty"`
	// Participants — enriched by client
	Src *FlowParticipant `protobuf:"bytes,11,opt,name=src,proto3" json:"src,omitempty"`
	Dst *FlowParticipant `protobuf:"bytes,12,opt,name=dst,proto3" json:"dst,omitempty"`
	// Timestamps (milliseconds since epoch)
	StartTsMs int64 `protobuf:"varint,13,opt,name=start_ts_ms,json=startTsMs,proto3" json:"start_ts_ms,omitempty"`
	EndTsMs   int64 `protobuf:"varint,14,opt,name=end_ts_ms,json=endTsMs,proto3" json:"end_ts_ms,omitempty"`
	// Traffic counters (only valid for destroy events)
	BytesSent   uint64 `protobuf:"varint,15,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"`
	BytesRecv   uint64 `protobuf:"varint,16,opt,name=bytes_recv,json=bytesRecv,proto3" json:"bytes_recv,omitempty"`
	PacketsSent uint64 `protobuf:"varint,17,opt,name=packets_sent,json=packetsSent,proto3" json:"packets_sent,omitempty"`
	PacketsRecv uint64 `protobuf:"varint,18,opt,name=packets_recv,json=packetsRecv,proto3" json:"packets_recv,omitempty"`
	// Netfilter conntrack status flags (bitmask)
	Status uint32 `protobuf:"varint,19,opt,name=status,proto3" json:"status,omitempty"`
	// *
	// Version used by ClickHouse for merging.
	// Must be strictly increasing for START → DESTROY.
	// Usually equal to the netclient event timestamp (ms).
	Version       int64 `protobuf:"varint,20,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FlowEvent) Reset() {
	*x = FlowEvent{}
	mi := &file_grpc_flow_flow_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FlowEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FlowEvent) ProtoMessage() {}

func (x *FlowEvent) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_flow_flow_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FlowEvent.ProtoReflect.Descriptor instead.
func (*FlowEvent) Descriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{1}
}

func (x *FlowEvent) GetType() EventType {
	if x != nil {
		return x.Type
	}
	return EventType_EVENT_TYPE_UNSPECIFIED
}

func (x *FlowEvent) GetFlowId() string {
	if x != nil {
		return x.FlowId
	}
	return ""
}

func (x *FlowEvent) GetNetworkId() string {
	if x != nil {
		return x.NetworkId
	}
	return ""
}

func (x *FlowEvent) GetHostId() string {
	if x != nil {
		return x.HostId
	}
	return ""
}

func (x *FlowEvent) GetProtocol() uint32 {
	if x != nil {
		return x.Protocol
	}
	return 0
}

func (x *FlowEvent) GetSrcPort() uint32 {
	if x != nil {
		return x.SrcPort
	}
	return 0
}

func (x *FlowEvent) GetDstPort() uint32 {
	if x != nil {
		return x.DstPort
	}
	return 0
}

func (x *FlowEvent) GetIcmpType() uint32 {
	if x != nil {
		return x.IcmpType
	}
	return 0
}

func (x *FlowEvent) GetIcmpCode() uint32 {
	if x != nil {
		return x.IcmpCode
	}
	return 0
}

func (x *FlowEvent) GetDirection() Direction {
	if x != nil {
		return x.Direction
	}
	return Direction_DIR_UNSPECIFIED
}

func (x *FlowEvent) GetSrc() *FlowParticipant {
	if x != nil {
		return x.Src
	}
	return nil
}

func (x *FlowEvent) GetDst() *FlowParticipant {
	if x != nil {
		return x.Dst
	}
	return nil
}

func (x *FlowEvent) GetStartTsMs() int64 {
	if x != nil {
		return x.StartTsMs
	}
	return 0
}

func (x *FlowEvent) GetEndTsMs() int64 {
	if x != nil {
		return x.EndTsMs
	}
	return 0
}

func (x *FlowEvent) GetBytesSent() uint64 {
	if x != nil {
		return x.BytesSent
	}
	return 0
}

func (x *FlowEvent) GetBytesRecv() uint64 {
	if x != nil {
		return x.BytesRecv
	}
	return 0
}

func (x *FlowEvent) GetPacketsSent() uint64 {
	if x != nil {
		return x.PacketsSent
	}
	return 0
}

func (x *FlowEvent) GetPacketsRecv() uint64 {
	if x != nil {
		return x.PacketsRecv
	}
	return 0
}

func (x *FlowEvent) GetStatus() uint32 {
	if x != nil {
		return x.Status
	}
	return 0
}

func (x *FlowEvent) GetVersion() int64 {
	if x != nil {
		return x.Version
	}
	return 0
}

// *
// Envelope sent by netclients containing multiple FlowEvents.
type FlowEnvelope struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Events        []*FlowEvent           `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FlowEnvelope) Reset() {
	*x = FlowEnvelope{}
	mi := &file_grpc_flow_flow_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FlowEnvelope) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FlowEnvelope) ProtoMessage() {}

func (x *FlowEnvelope) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_flow_flow_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FlowEnvelope.ProtoReflect.Descriptor instead.
func (*FlowEnvelope) Descriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{2}
}

func (x *FlowEnvelope) GetEvents() []*FlowEvent {
	if x != nil {
		return x.Events
	}
	return nil
}

// *
// Response from server acknowledging receipt of a batch.
type FlowResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` // true if batch was accepted
	Error         string                 `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`      // optional error information
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FlowResponse) Reset() {
	*x = FlowResponse{}
	mi := &file_grpc_flow_flow_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FlowResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FlowResponse) ProtoMessage() {}

func (x *FlowResponse) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_flow_flow_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FlowResponse.ProtoReflect.Descriptor instead.
func (*FlowResponse) Descriptor() ([]byte, []int) {
	return file_grpc_flow_flow_proto_rawDescGZIP(), []int{3}
}

func (x *FlowResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *FlowResponse) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

var File_grpc_flow_flow_proto protoreflect.FileDescriptor

const file_grpc_flow_flow_proto_rawDesc = "" +
	"\n" +
	"\x14grpc/flow/flow.proto\x12\rnetmaker.flow\"e\n" +
	"\x0fFlowParticipant\x12\x0e\n" +
	"\x02ip\x18\x01 \x01(\tR\x02ip\x122\n" +
	"\x04type\x18\x02 \x01(\x0e2\x1e.netmaker.flow.ParticipantTypeR\x04type\x12\x0e\n" +
	"\x02id\x18\x03 \x01(\tR\x02id\"\xa4\x05\n" +
	"\tFlowEvent\x12,\n" +
	"\x04type\x18\x01 \x01(\x0e2\x18.netmaker.flow.EventTypeR\x04type\x12\x17\n" +
	"\aflow_id\x18\x02 \x01(\tR\x06flowId\x12\x1d\n" +
	"\n" +
	"network_id\x18\x03 \x01(\tR\tnetworkId\x12\x17\n" +
	"\ahost_id\x18\x04 \x01(\tR\x06hostId\x12\x1a\n" +
	"\bprotocol\x18\x05 \x01(\rR\bprotocol\x12\x19\n" +
	"\bsrc_port\x18\x06 \x01(\rR\asrcPort\x12\x19\n" +
	"\bdst_port\x18\a \x01(\rR\adstPort\x12\x1b\n" +
	"\ticmp_type\x18\b \x01(\rR\bicmpType\x12\x1b\n" +
	"\ticmp_code\x18\t \x01(\rR\bicmpCode\x126\n" +
	"\tdirection\x18\n" +
	" \x01(\x0e2\x18.netmaker.flow.DirectionR\tdirection\x120\n" +
	"\x03src\x18\v \x01(\v2\x1e.netmaker.flow.FlowParticipantR\x03src\x120\n" +
	"\x03dst\x18\f \x01(\v2\x1e.netmaker.flow.FlowParticipantR\x03dst\x12\x1e\n" +
	"\vstart_ts_ms\x18\r \x01(\x03R\tstartTsMs\x12\x1a\n" +
	"\tend_ts_ms\x18\x0e \x01(\x03R\aendTsMs\x12\x1d\n" +
	"\n" +
	"bytes_sent\x18\x0f \x01(\x04R\tbytesSent\x12\x1d\n" +
	"\n" +
	"bytes_recv\x18\x10 \x01(\x04R\tbytesRecv\x12!\n" +
	"\fpackets_sent\x18\x11 \x01(\x04R\vpacketsSent\x12!\n" +
	"\fpackets_recv\x18\x12 \x01(\x04R\vpacketsRecv\x12\x16\n" +
	"\x06status\x18\x13 \x01(\rR\x06status\x12\x18\n" +
	"\aversion\x18\x14 \x01(\x03R\aversion\"@\n" +
	"\fFlowEnvelope\x120\n" +
	"\x06events\x18\x01 \x03(\v2\x18.netmaker.flow.FlowEventR\x06events\">\n" +
	"\fFlowResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error*K\n" +
	"\tEventType\x12\x1a\n" +
	"\x16EVENT_TYPE_UNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vEVENT_START\x10\x01\x12\x11\n" +
	"\rEVENT_DESTROY\x10\x02*\xad\x01\n" +
	"\x0fParticipantType\x12\x1b\n" +
	"\x17PARTICIPANT_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10PARTICIPANT_NODE\x10\x01\x12\x14\n" +
	"\x10PARTICIPANT_USER\x10\x02\x12\x19\n" +
	"\x15PARTICIPANT_EXTCLIENT\x10\x03\x12\x1c\n" +
	"\x18PARTICIPANT_EGRESS_ROUTE\x10\x04\x12\x18\n" +
	"\x14PARTICIPANT_EXTERNAL\x10\x05*A\n" +
	"\tDirection\x12\x13\n" +
	"\x0fDIR_UNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vDIR_INGRESS\x10\x01\x12\x0e\n" +
	"\n" +
	"DIR_EGRESS\x10\x022Z\n" +
	"\vFlowService\x12K\n" +
	"\vStreamFlows\x12\x1b.netmaker.flow.FlowEnvelope\x1a\x1b.netmaker.flow.FlowResponse(\x010\x01B'Z%github.com/gravitl/netmaker/grpc/flowb\x06proto3"

var (
	file_grpc_flow_flow_proto_rawDescOnce sync.Once
	file_grpc_flow_flow_proto_rawDescData []byte
)

func file_grpc_flow_flow_proto_rawDescGZIP() []byte {
	file_grpc_flow_flow_proto_rawDescOnce.Do(func() {
		file_grpc_flow_flow_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_grpc_flow_flow_proto_rawDesc), len(file_grpc_flow_flow_proto_rawDesc)))
	})
	return file_grpc_flow_flow_proto_rawDescData
}

var file_grpc_flow_flow_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_grpc_flow_flow_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
var file_grpc_flow_flow_proto_goTypes = []any{
	(EventType)(0),          // 0: netmaker.flow.EventType
	(ParticipantType)(0),    // 1: netmaker.flow.ParticipantType
	(Direction)(0),          // 2: netmaker.flow.Direction
	(*FlowParticipant)(nil), // 3: netmaker.flow.FlowParticipant
	(*FlowEvent)(nil),       // 4: netmaker.flow.FlowEvent
	(*FlowEnvelope)(nil),    // 5: netmaker.flow.FlowEnvelope
	(*FlowResponse)(nil),    // 6: netmaker.flow.FlowResponse
}
var file_grpc_flow_flow_proto_depIdxs = []int32{
	1, // 0: netmaker.flow.FlowParticipant.type:type_name -> netmaker.flow.ParticipantType
	0, // 1: netmaker.flow.FlowEvent.type:type_name -> netmaker.flow.EventType
	2, // 2: netmaker.flow.FlowEvent.direction:type_name -> netmaker.flow.Direction
	3, // 3: netmaker.flow.FlowEvent.src:type_name -> netmaker.flow.FlowParticipant
	3, // 4: netmaker.flow.FlowEvent.dst:type_name -> netmaker.flow.FlowParticipant
	4, // 5: netmaker.flow.FlowEnvelope.events:type_name -> netmaker.flow.FlowEvent
	5, // 6: netmaker.flow.FlowService.StreamFlows:input_type -> netmaker.flow.FlowEnvelope
	6, // 7: netmaker.flow.FlowService.StreamFlows:output_type -> netmaker.flow.FlowResponse
	7, // [7:8] is the sub-list for method output_type
	6, // [6:7] is the sub-list for method input_type
	6, // [6:6] is the sub-list for extension type_name
	6, // [6:6] is the sub-list for extension extendee
	0, // [0:6] is the sub-list for field type_name
}

func init() { file_grpc_flow_flow_proto_init() }
func file_grpc_flow_flow_proto_init() {
	if File_grpc_flow_flow_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_grpc_flow_flow_proto_rawDesc), len(file_grpc_flow_flow_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   4,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_grpc_flow_flow_proto_goTypes,
		DependencyIndexes: file_grpc_flow_flow_proto_depIdxs,
		EnumInfos:         file_grpc_flow_flow_proto_enumTypes,
		MessageInfos:      file_grpc_flow_flow_proto_msgTypes,
	}.Build()
	File_grpc_flow_flow_proto = out.File
	file_grpc_flow_flow_proto_goTypes = nil
	file_grpc_flow_flow_proto_depIdxs = nil
}