// Copyright 2020 Authors of Cilium
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v4.25.2
// source: ui/ui.proto

package ui

import (
	flow "github.com/cilium/cilium/api/v1/flow"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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)
)

type EventType int32

const (
	EventType_UNKNOWN_EVENT       EventType = 0
	EventType_FLOW                EventType = 1
	EventType_K8S_NAMESPACE_STATE EventType = 2
	EventType_SERVICE_STATE       EventType = 3
	EventType_SERVICE_LINK_STATE  EventType = 4
	EventType_FLOWS               EventType = 5
	EventType_STATUS              EventType = 6
)

// Enum value maps for EventType.
var (
	EventType_name = map[int32]string{
		0: "UNKNOWN_EVENT",
		1: "FLOW",
		2: "K8S_NAMESPACE_STATE",
		3: "SERVICE_STATE",
		4: "SERVICE_LINK_STATE",
		5: "FLOWS",
		6: "STATUS",
	}
	EventType_value = map[string]int32{
		"UNKNOWN_EVENT":       0,
		"FLOW":                1,
		"K8S_NAMESPACE_STATE": 2,
		"SERVICE_STATE":       3,
		"SERVICE_LINK_STATE":  4,
		"FLOWS":               5,
		"STATUS":              6,
	}
)

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_ui_ui_proto_enumTypes[0].Descriptor()
}

func (EventType) Type() protoreflect.EnumType {
	return &file_ui_ui_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_ui_ui_proto_rawDescGZIP(), []int{0}
}

// IP protocols. The values of enums do not correspond to actual IP protocol numbers.
type IPProtocol int32

const (
	IPProtocol_UNKNOWN_IP_PROTOCOL IPProtocol = 0
	IPProtocol_TCP                 IPProtocol = 1
	IPProtocol_UDP                 IPProtocol = 2
	IPProtocol_ICMP_V4             IPProtocol = 3
	IPProtocol_ICMP_V6             IPProtocol = 4
)

// Enum value maps for IPProtocol.
var (
	IPProtocol_name = map[int32]string{
		0: "UNKNOWN_IP_PROTOCOL",
		1: "TCP",
		2: "UDP",
		3: "ICMP_V4",
		4: "ICMP_V6",
	}
	IPProtocol_value = map[string]int32{
		"UNKNOWN_IP_PROTOCOL": 0,
		"TCP":                 1,
		"UDP":                 2,
		"ICMP_V4":             3,
		"ICMP_V6":             4,
	}
)

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

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

func (IPProtocol) Descriptor() protoreflect.EnumDescriptor {
	return file_ui_ui_proto_enumTypes[1].Descriptor()
}

func (IPProtocol) Type() protoreflect.EnumType {
	return &file_ui_ui_proto_enumTypes[1]
}

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

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

type StateChange int32

const (
	StateChange_UNKNOWN_STATE_CHANGE StateChange = 0
	StateChange_ADDED                StateChange = 1
	StateChange_MODIFIED             StateChange = 2
	StateChange_DELETED              StateChange = 3
	// This is needed in case the relay server knows that the service exists,
	// but it doesn't know when it got created.
	StateChange_EXISTS StateChange = 4
)

// Enum value maps for StateChange.
var (
	StateChange_name = map[int32]string{
		0: "UNKNOWN_STATE_CHANGE",
		1: "ADDED",
		2: "MODIFIED",
		3: "DELETED",
		4: "EXISTS",
	}
	StateChange_value = map[string]int32{
		"UNKNOWN_STATE_CHANGE": 0,
		"ADDED":                1,
		"MODIFIED":             2,
		"DELETED":              3,
		"EXISTS":               4,
	}
)

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

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

func (StateChange) Descriptor() protoreflect.EnumDescriptor {
	return file_ui_ui_proto_enumTypes[2].Descriptor()
}

func (StateChange) Type() protoreflect.EnumType {
	return &file_ui_ui_proto_enumTypes[2]
}

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

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

// Here I didn't include "follow", "until", and "number". This request assumes follow,
// and lets the client decide when to end the request, whether it's based on timestamp
// or the number of responses received.
type GetEventsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// EventType specifies which types of events to subscribe to. If unspecified, the
	// request is subscribed to all the event types.
	EventTypes    []EventType            `protobuf:"varint,1,rep,packed,name=event_types,json=eventTypes,proto3,enum=ui.EventType" json:"event_types,omitempty"`
	Blacklist     []*EventFilter         `protobuf:"bytes,2,rep,name=blacklist,proto3" json:"blacklist,omitempty"`
	Whitelist     []*EventFilter         `protobuf:"bytes,3,rep,name=whitelist,proto3" json:"whitelist,omitempty"`
	Since         *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=since,proto3" json:"since,omitempty"`
	StatusRequest *GetStatusRequest      `protobuf:"bytes,5,opt,name=status_request,json=statusRequest,proto3" json:"status_request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetEventsRequest) ProtoMessage() {}

func (x *GetEventsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_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 GetEventsRequest.ProtoReflect.Descriptor instead.
func (*GetEventsRequest) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{0}
}

func (x *GetEventsRequest) GetEventTypes() []EventType {
	if x != nil {
		return x.EventTypes
	}
	return nil
}

func (x *GetEventsRequest) GetBlacklist() []*EventFilter {
	if x != nil {
		return x.Blacklist
	}
	return nil
}

func (x *GetEventsRequest) GetWhitelist() []*EventFilter {
	if x != nil {
		return x.Whitelist
	}
	return nil
}

func (x *GetEventsRequest) GetSince() *timestamppb.Timestamp {
	if x != nil {
		return x.Since
	}
	return nil
}

func (x *GetEventsRequest) GetStatusRequest() *GetStatusRequest {
	if x != nil {
		return x.StatusRequest
	}
	return nil
}

type GetEventsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Node          string                 `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Events        []*Event               `protobuf:"bytes,3,rep,name=events,proto3" json:"events,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetEventsResponse) ProtoMessage() {}

func (x *GetEventsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_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 GetEventsResponse.ProtoReflect.Descriptor instead.
func (*GetEventsResponse) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{1}
}

func (x *GetEventsResponse) GetNode() string {
	if x != nil {
		return x.Node
	}
	return ""
}

func (x *GetEventsResponse) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

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

type Event struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*Event_Flow
	//	*Event_NamespaceState
	//	*Event_ServiceState
	//	*Event_ServiceLinkState
	//	*Event_Flows
	//	*Event_Notification
	Event         isEvent_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Event) ProtoMessage() {}

func (x *Event) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_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 Event.ProtoReflect.Descriptor instead.
func (*Event) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{2}
}

func (x *Event) GetEvent() isEvent_Event {
	if x != nil {
		return x.Event
	}
	return nil
}

func (x *Event) GetFlow() *flow.Flow {
	if x != nil {
		if x, ok := x.Event.(*Event_Flow); ok {
			return x.Flow
		}
	}
	return nil
}

func (x *Event) GetNamespaceState() *NamespaceState {
	if x != nil {
		if x, ok := x.Event.(*Event_NamespaceState); ok {
			return x.NamespaceState
		}
	}
	return nil
}

func (x *Event) GetServiceState() *ServiceState {
	if x != nil {
		if x, ok := x.Event.(*Event_ServiceState); ok {
			return x.ServiceState
		}
	}
	return nil
}

func (x *Event) GetServiceLinkState() *ServiceLinkState {
	if x != nil {
		if x, ok := x.Event.(*Event_ServiceLinkState); ok {
			return x.ServiceLinkState
		}
	}
	return nil
}

func (x *Event) GetFlows() *Flows {
	if x != nil {
		if x, ok := x.Event.(*Event_Flows); ok {
			return x.Flows
		}
	}
	return nil
}

func (x *Event) GetNotification() *Notification {
	if x != nil {
		if x, ok := x.Event.(*Event_Notification); ok {
			return x.Notification
		}
	}
	return nil
}

type isEvent_Event interface {
	isEvent_Event()
}

type Event_Flow struct {
	Flow *flow.Flow `protobuf:"bytes,3,opt,name=flow,proto3,oneof"`
}

type Event_NamespaceState struct {
	NamespaceState *NamespaceState `protobuf:"bytes,4,opt,name=namespace_state,json=namespaceState,proto3,oneof"`
}

type Event_ServiceState struct {
	ServiceState *ServiceState `protobuf:"bytes,5,opt,name=service_state,json=serviceState,proto3,oneof"`
}

type Event_ServiceLinkState struct {
	// It's unclear how we can define what it means for service links to get
	// added/deleted. For now I'm deferring the decision for whether a
	// particular link should be included in the service map to the client.
	// Maybe the server can periodically send service_link events for active
	// links to keep-alive, and the client can expire older links based on their
	// timestamp.
	ServiceLinkState *ServiceLinkState `protobuf:"bytes,6,opt,name=service_link_state,json=serviceLinkState,proto3,oneof"`
}

type Event_Flows struct {
	Flows *Flows `protobuf:"bytes,7,opt,name=flows,proto3,oneof"`
}

type Event_Notification struct {
	Notification *Notification `protobuf:"bytes,8,opt,name=notification,proto3,oneof"`
}

func (*Event_Flow) isEvent_Event() {}

func (*Event_NamespaceState) isEvent_Event() {}

func (*Event_ServiceState) isEvent_Event() {}

func (*Event_ServiceLinkState) isEvent_Event() {}

func (*Event_Flows) isEvent_Event() {}

func (*Event_Notification) isEvent_Event() {}

type Flows struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Flows         []*flow.Flow           `protobuf:"bytes,1,rep,name=flows,proto3" json:"flows,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Flows) ProtoMessage() {}

func (x *Flows) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_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 Flows.ProtoReflect.Descriptor instead.
func (*Flows) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{3}
}

func (x *Flows) GetFlows() []*flow.Flow {
	if x != nil {
		return x.Flows
	}
	return nil
}

// Here I added different filter types for different events. Another option is to reuse
// and extend FlowFilter to filter all the events, but I worry that it might become too
// confusing in terms of figuring out which filter fields apply to which events.
type EventFilter struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Filter:
	//
	//	*EventFilter_FlowFilter
	//	*EventFilter_ServiceFilter
	//	*EventFilter_ServiceLinkFilter
	Filter        isEventFilter_Filter `protobuf_oneof:"filter"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EventFilter) Reset() {
	*x = EventFilter{}
	mi := &file_ui_ui_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*EventFilter) ProtoMessage() {}

func (x *EventFilter) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[4]
	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 EventFilter.ProtoReflect.Descriptor instead.
func (*EventFilter) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{4}
}

func (x *EventFilter) GetFilter() isEventFilter_Filter {
	if x != nil {
		return x.Filter
	}
	return nil
}

func (x *EventFilter) GetFlowFilter() *flow.FlowFilter {
	if x != nil {
		if x, ok := x.Filter.(*EventFilter_FlowFilter); ok {
			return x.FlowFilter
		}
	}
	return nil
}

func (x *EventFilter) GetServiceFilter() *ServiceFilter {
	if x != nil {
		if x, ok := x.Filter.(*EventFilter_ServiceFilter); ok {
			return x.ServiceFilter
		}
	}
	return nil
}

func (x *EventFilter) GetServiceLinkFilter() *ServiceLinkFilter {
	if x != nil {
		if x, ok := x.Filter.(*EventFilter_ServiceLinkFilter); ok {
			return x.ServiceLinkFilter
		}
	}
	return nil
}

type isEventFilter_Filter interface {
	isEventFilter_Filter()
}

type EventFilter_FlowFilter struct {
	FlowFilter *flow.FlowFilter `protobuf:"bytes,2,opt,name=flow_filter,json=flowFilter,proto3,oneof"`
}

type EventFilter_ServiceFilter struct {
	ServiceFilter *ServiceFilter `protobuf:"bytes,3,opt,name=service_filter,json=serviceFilter,proto3,oneof"`
}

type EventFilter_ServiceLinkFilter struct {
	ServiceLinkFilter *ServiceLinkFilter `protobuf:"bytes,4,opt,name=service_link_filter,json=serviceLinkFilter,proto3,oneof"`
}

func (*EventFilter_FlowFilter) isEventFilter_Filter() {}

func (*EventFilter_ServiceFilter) isEventFilter_Filter() {}

func (*EventFilter_ServiceLinkFilter) isEventFilter_Filter() {}

type NamespaceDescriptor struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	Id                string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name              string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	CreationTimestamp *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=creation_timestamp,json=creationTimestamp,proto3" json:"creation_timestamp,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *NamespaceDescriptor) Reset() {
	*x = NamespaceDescriptor{}
	mi := &file_ui_ui_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*NamespaceDescriptor) ProtoMessage() {}

func (x *NamespaceDescriptor) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[5]
	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 NamespaceDescriptor.ProtoReflect.Descriptor instead.
func (*NamespaceDescriptor) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{5}
}

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

func (x *NamespaceDescriptor) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *NamespaceDescriptor) GetCreationTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.CreationTimestamp
	}
	return nil
}

type NamespaceState struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Namespace     *NamespaceDescriptor   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Type          StateChange            `protobuf:"varint,2,opt,name=type,proto3,enum=ui.StateChange" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NamespaceState) Reset() {
	*x = NamespaceState{}
	mi := &file_ui_ui_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*NamespaceState) ProtoMessage() {}

func (x *NamespaceState) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[6]
	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 NamespaceState.ProtoReflect.Descriptor instead.
func (*NamespaceState) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{6}
}

func (x *NamespaceState) GetNamespace() *NamespaceDescriptor {
	if x != nil {
		return x.Namespace
	}
	return nil
}

func (x *NamespaceState) GetType() StateChange {
	if x != nil {
		return x.Type
	}
	return StateChange_UNKNOWN_STATE_CHANGE
}

// Come up with a better name for Service.
type Service struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An opaque ID that uniquely identifies the service.
	Id                    string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name                  string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Namespace             string   `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Labels                []string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty"`
	DnsNames              []string `protobuf:"bytes,5,rep,name=dns_names,json=dnsNames,proto3" json:"dns_names,omitempty"`
	EgressPolicyEnforced  bool     `protobuf:"varint,6,opt,name=egress_policy_enforced,json=egressPolicyEnforced,proto3" json:"egress_policy_enforced,omitempty"`
	IngressPolicyEnforced bool     `protobuf:"varint,7,opt,name=ingress_policy_enforced,json=ingressPolicyEnforced,proto3" json:"ingress_policy_enforced,omitempty"`
	// This is a string instead of boolean because Cilium reports status message. If it's
	// successfully enabled, this string is set to "OK" I think.
	VisibilityPolicyStatus string `protobuf:"bytes,8,opt,name=visibility_policy_status,json=visibilityPolicyStatus,proto3" json:"visibility_policy_status,omitempty"`
	// We probably can't reliably set creation timestamp.
	CreationTimestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=creation_timestamp,json=creationTimestamp,proto3" json:"creation_timestamp,omitempty"`
	Workloads         []*flow.Workload       `protobuf:"bytes,10,rep,name=workloads,proto3" json:"workloads,omitempty"`
	Identity          uint32                 `protobuf:"varint,12,opt,name=identity,proto3" json:"identity,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *Service) Reset() {
	*x = Service{}
	mi := &file_ui_ui_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Service) ProtoMessage() {}

func (x *Service) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[7]
	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 Service.ProtoReflect.Descriptor instead.
func (*Service) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{7}
}

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

func (x *Service) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Service) GetNamespace() string {
	if x != nil {
		return x.Namespace
	}
	return ""
}

func (x *Service) GetLabels() []string {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *Service) GetDnsNames() []string {
	if x != nil {
		return x.DnsNames
	}
	return nil
}

func (x *Service) GetEgressPolicyEnforced() bool {
	if x != nil {
		return x.EgressPolicyEnforced
	}
	return false
}

func (x *Service) GetIngressPolicyEnforced() bool {
	if x != nil {
		return x.IngressPolicyEnforced
	}
	return false
}

func (x *Service) GetVisibilityPolicyStatus() string {
	if x != nil {
		return x.VisibilityPolicyStatus
	}
	return ""
}

func (x *Service) GetCreationTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.CreationTimestamp
	}
	return nil
}

func (x *Service) GetWorkloads() []*flow.Workload {
	if x != nil {
		return x.Workloads
	}
	return nil
}

func (x *Service) GetIdentity() uint32 {
	if x != nil {
		return x.Identity
	}
	return 0
}

type ServiceState struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Service       *Service               `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	Type          StateChange            `protobuf:"varint,2,opt,name=type,proto3,enum=ui.StateChange" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ServiceState) Reset() {
	*x = ServiceState{}
	mi := &file_ui_ui_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServiceState) ProtoMessage() {}

func (x *ServiceState) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[8]
	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 ServiceState.ProtoReflect.Descriptor instead.
func (*ServiceState) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{8}
}

func (x *ServiceState) GetService() *Service {
	if x != nil {
		return x.Service
	}
	return nil
}

func (x *ServiceState) GetType() StateChange {
	if x != nil {
		return x.Type
	}
	return StateChange_UNKNOWN_STATE_CHANGE
}

type ServiceFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Namespace     []string               `protobuf:"bytes,1,rep,name=namespace,proto3" json:"namespace,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ServiceFilter) Reset() {
	*x = ServiceFilter{}
	mi := &file_ui_ui_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServiceFilter) ProtoMessage() {}

func (x *ServiceFilter) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[9]
	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 ServiceFilter.ProtoReflect.Descriptor instead.
func (*ServiceFilter) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{9}
}

func (x *ServiceFilter) GetNamespace() []string {
	if x != nil {
		return x.Namespace
	}
	return nil
}

type ServiceLink struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An opaque ID that uniquely identifies this link.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// source Service id
	SourceId string `protobuf:"bytes,2,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"`
	// destination Service id
	DestinationId   string               `protobuf:"bytes,3,opt,name=destination_id,json=destinationId,proto3" json:"destination_id,omitempty"`
	DestinationPort uint32               `protobuf:"varint,4,opt,name=destination_port,json=destinationPort,proto3" json:"destination_port,omitempty"`
	IpProtocol      IPProtocol           `protobuf:"varint,5,opt,name=ip_protocol,json=ipProtocol,proto3,enum=ui.IPProtocol" json:"ip_protocol,omitempty"`
	Verdict         flow.Verdict         `protobuf:"varint,6,opt,name=verdict,proto3,enum=flow.Verdict" json:"verdict,omitempty"`
	FlowAmount      uint64               `protobuf:"varint,7,opt,name=flow_amount,json=flowAmount,proto3" json:"flow_amount,omitempty"`
	Latency         *ServiceLink_Latency `protobuf:"bytes,8,opt,name=latency,proto3" json:"latency,omitempty"`
	BytesTransfered uint64               `protobuf:"varint,9,opt,name=bytes_transfered,json=bytesTransfered,proto3" json:"bytes_transfered,omitempty"`
	AuthType        flow.AuthType        `protobuf:"varint,10,opt,name=auth_type,json=authType,proto3,enum=flow.AuthType" json:"auth_type,omitempty"`
	IsEncrypted     bool                 `protobuf:"varint,11,opt,name=is_encrypted,json=isEncrypted,proto3" json:"is_encrypted,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *ServiceLink) Reset() {
	*x = ServiceLink{}
	mi := &file_ui_ui_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServiceLink) ProtoMessage() {}

func (x *ServiceLink) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[10]
	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 ServiceLink.ProtoReflect.Descriptor instead.
func (*ServiceLink) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{10}
}

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

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

func (x *ServiceLink) GetDestinationId() string {
	if x != nil {
		return x.DestinationId
	}
	return ""
}

func (x *ServiceLink) GetDestinationPort() uint32 {
	if x != nil {
		return x.DestinationPort
	}
	return 0
}

func (x *ServiceLink) GetIpProtocol() IPProtocol {
	if x != nil {
		return x.IpProtocol
	}
	return IPProtocol_UNKNOWN_IP_PROTOCOL
}

func (x *ServiceLink) GetVerdict() flow.Verdict {
	if x != nil {
		return x.Verdict
	}
	return flow.Verdict(0)
}

func (x *ServiceLink) GetFlowAmount() uint64 {
	if x != nil {
		return x.FlowAmount
	}
	return 0
}

func (x *ServiceLink) GetLatency() *ServiceLink_Latency {
	if x != nil {
		return x.Latency
	}
	return nil
}

func (x *ServiceLink) GetBytesTransfered() uint64 {
	if x != nil {
		return x.BytesTransfered
	}
	return 0
}

func (x *ServiceLink) GetAuthType() flow.AuthType {
	if x != nil {
		return x.AuthType
	}
	return flow.AuthType(0)
}

func (x *ServiceLink) GetIsEncrypted() bool {
	if x != nil {
		return x.IsEncrypted
	}
	return false
}

type ServiceLinkState struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ServiceLink   *ServiceLink           `protobuf:"bytes,1,opt,name=service_link,json=serviceLink,proto3" json:"service_link,omitempty"`
	Type          StateChange            `protobuf:"varint,2,opt,name=type,proto3,enum=ui.StateChange" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ServiceLinkState) Reset() {
	*x = ServiceLinkState{}
	mi := &file_ui_ui_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServiceLinkState) ProtoMessage() {}

func (x *ServiceLinkState) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[11]
	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 ServiceLinkState.ProtoReflect.Descriptor instead.
func (*ServiceLinkState) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{11}
}

func (x *ServiceLinkState) GetServiceLink() *ServiceLink {
	if x != nil {
		return x.ServiceLink
	}
	return nil
}

func (x *ServiceLinkState) GetType() StateChange {
	if x != nil {
		return x.Type
	}
	return StateChange_UNKNOWN_STATE_CHANGE
}

type ServiceLinkFilter struct {
	state       protoimpl.MessageState `protogen:"open.v1"`
	Source      []*ServiceFilter       `protobuf:"bytes,1,rep,name=source,proto3" json:"source,omitempty"`
	Destination []*ServiceFilter       `protobuf:"bytes,2,rep,name=destination,proto3" json:"destination,omitempty"`
	// Use string here to support things like port ranges (e.g. 100-200).
	DestinationPort []string       `protobuf:"bytes,3,rep,name=destination_port,json=destinationPort,proto3" json:"destination_port,omitempty"`
	Verdict         []flow.Verdict `protobuf:"varint,4,rep,packed,name=verdict,proto3,enum=flow.Verdict" json:"verdict,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *ServiceLinkFilter) Reset() {
	*x = ServiceLinkFilter{}
	mi := &file_ui_ui_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServiceLinkFilter) ProtoMessage() {}

func (x *ServiceLinkFilter) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[12]
	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 ServiceLinkFilter.ProtoReflect.Descriptor instead.
func (*ServiceLinkFilter) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{12}
}

func (x *ServiceLinkFilter) GetSource() []*ServiceFilter {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *ServiceLinkFilter) GetDestination() []*ServiceFilter {
	if x != nil {
		return x.Destination
	}
	return nil
}

func (x *ServiceLinkFilter) GetDestinationPort() []string {
	if x != nil {
		return x.DestinationPort
	}
	return nil
}

func (x *ServiceLinkFilter) GetVerdict() []flow.Verdict {
	if x != nil {
		return x.Verdict
	}
	return nil
}

type GetControlStreamRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetControlStreamRequest) Reset() {
	*x = GetControlStreamRequest{}
	mi := &file_ui_ui_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetControlStreamRequest) ProtoMessage() {}

func (x *GetControlStreamRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[13]
	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 GetControlStreamRequest.ProtoReflect.Descriptor instead.
func (*GetControlStreamRequest) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{13}
}

type GetControlStreamResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*GetControlStreamResponse_Namespaces
	//	*GetControlStreamResponse_Notification
	Event         isGetControlStreamResponse_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetControlStreamResponse) Reset() {
	*x = GetControlStreamResponse{}
	mi := &file_ui_ui_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetControlStreamResponse) ProtoMessage() {}

func (x *GetControlStreamResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[14]
	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 GetControlStreamResponse.ProtoReflect.Descriptor instead.
func (*GetControlStreamResponse) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{14}
}

func (x *GetControlStreamResponse) GetEvent() isGetControlStreamResponse_Event {
	if x != nil {
		return x.Event
	}
	return nil
}

func (x *GetControlStreamResponse) GetNamespaces() *GetControlStreamResponse_NamespaceStates {
	if x != nil {
		if x, ok := x.Event.(*GetControlStreamResponse_Namespaces); ok {
			return x.Namespaces
		}
	}
	return nil
}

func (x *GetControlStreamResponse) GetNotification() *Notification {
	if x != nil {
		if x, ok := x.Event.(*GetControlStreamResponse_Notification); ok {
			return x.Notification
		}
	}
	return nil
}

type isGetControlStreamResponse_Event interface {
	isGetControlStreamResponse_Event()
}

type GetControlStreamResponse_Namespaces struct {
	Namespaces *GetControlStreamResponse_NamespaceStates `protobuf:"bytes,1,opt,name=namespaces,proto3,oneof"`
}

type GetControlStreamResponse_Notification struct {
	Notification *Notification `protobuf:"bytes,2,opt,name=notification,proto3,oneof"`
}

func (*GetControlStreamResponse_Namespaces) isGetControlStreamResponse_Event() {}

func (*GetControlStreamResponse_Notification) isGetControlStreamResponse_Event() {}

type ServiceLink_Latency struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Min           *durationpb.Duration   `protobuf:"bytes,1,opt,name=min,proto3" json:"min,omitempty"`
	Max           *durationpb.Duration   `protobuf:"bytes,2,opt,name=max,proto3" json:"max,omitempty"`
	Avg           *durationpb.Duration   `protobuf:"bytes,3,opt,name=avg,proto3" json:"avg,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ServiceLink_Latency) Reset() {
	*x = ServiceLink_Latency{}
	mi := &file_ui_ui_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServiceLink_Latency) ProtoMessage() {}

func (x *ServiceLink_Latency) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[15]
	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 ServiceLink_Latency.ProtoReflect.Descriptor instead.
func (*ServiceLink_Latency) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{10, 0}
}

func (x *ServiceLink_Latency) GetMin() *durationpb.Duration {
	if x != nil {
		return x.Min
	}
	return nil
}

func (x *ServiceLink_Latency) GetMax() *durationpb.Duration {
	if x != nil {
		return x.Max
	}
	return nil
}

func (x *ServiceLink_Latency) GetAvg() *durationpb.Duration {
	if x != nil {
		return x.Avg
	}
	return nil
}

type GetControlStreamResponse_NamespaceStates struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Namespaces    []*NamespaceState      `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetControlStreamResponse_NamespaceStates) Reset() {
	*x = GetControlStreamResponse_NamespaceStates{}
	mi := &file_ui_ui_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetControlStreamResponse_NamespaceStates) ProtoMessage() {}

func (x *GetControlStreamResponse_NamespaceStates) ProtoReflect() protoreflect.Message {
	mi := &file_ui_ui_proto_msgTypes[16]
	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 GetControlStreamResponse_NamespaceStates.ProtoReflect.Descriptor instead.
func (*GetControlStreamResponse_NamespaceStates) Descriptor() ([]byte, []int) {
	return file_ui_ui_proto_rawDescGZIP(), []int{14, 0}
}

func (x *GetControlStreamResponse_NamespaceStates) GetNamespaces() []*NamespaceState {
	if x != nil {
		return x.Namespaces
	}
	return nil
}

var File_ui_ui_proto protoreflect.FileDescriptor

const file_ui_ui_proto_rawDesc = "" +
	"\n" +
	"\vui/ui.proto\x12\x02ui\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x0fflow/flow.proto\x1a\x16ui/notifications.proto\x1a\x0fui/status.proto\"\x8f\x02\n" +
	"\x10GetEventsRequest\x12.\n" +
	"\vevent_types\x18\x01 \x03(\x0e2\r.ui.EventTypeR\n" +
	"eventTypes\x12-\n" +
	"\tblacklist\x18\x02 \x03(\v2\x0f.ui.EventFilterR\tblacklist\x12-\n" +
	"\twhitelist\x18\x03 \x03(\v2\x0f.ui.EventFilterR\twhitelist\x120\n" +
	"\x05since\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\x05since\x12;\n" +
	"\x0estatus_request\x18\x05 \x01(\v2\x14.ui.GetStatusRequestR\rstatusRequest\"\x84\x01\n" +
	"\x11GetEventsResponse\x12\x12\n" +
	"\x04node\x18\x01 \x01(\tR\x04node\x128\n" +
	"\ttimestamp\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12!\n" +
	"\x06events\x18\x03 \x03(\v2\t.ui.EventR\x06events\"\xcb\x02\n" +
	"\x05Event\x12 \n" +
	"\x04flow\x18\x03 \x01(\v2\n" +
	".flow.FlowH\x00R\x04flow\x12=\n" +
	"\x0fnamespace_state\x18\x04 \x01(\v2\x12.ui.NamespaceStateH\x00R\x0enamespaceState\x127\n" +
	"\rservice_state\x18\x05 \x01(\v2\x10.ui.ServiceStateH\x00R\fserviceState\x12D\n" +
	"\x12service_link_state\x18\x06 \x01(\v2\x14.ui.ServiceLinkStateH\x00R\x10serviceLinkState\x12!\n" +
	"\x05flows\x18\a \x01(\v2\t.ui.FlowsH\x00R\x05flows\x126\n" +
	"\fnotification\x18\b \x01(\v2\x10.ui.NotificationH\x00R\fnotificationB\a\n" +
	"\x05event\")\n" +
	"\x05Flows\x12 \n" +
	"\x05flows\x18\x01 \x03(\v2\n" +
	".flow.FlowR\x05flows\"\xd1\x01\n" +
	"\vEventFilter\x123\n" +
	"\vflow_filter\x18\x02 \x01(\v2\x10.flow.FlowFilterH\x00R\n" +
	"flowFilter\x12:\n" +
	"\x0eservice_filter\x18\x03 \x01(\v2\x11.ui.ServiceFilterH\x00R\rserviceFilter\x12G\n" +
	"\x13service_link_filter\x18\x04 \x01(\v2\x15.ui.ServiceLinkFilterH\x00R\x11serviceLinkFilterB\b\n" +
	"\x06filter\"\x84\x01\n" +
	"\x13NamespaceDescriptor\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12I\n" +
	"\x12creation_timestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x11creationTimestamp\"l\n" +
	"\x0eNamespaceState\x125\n" +
	"\tnamespace\x18\x01 \x01(\v2\x17.ui.NamespaceDescriptorR\tnamespace\x12#\n" +
	"\x04type\x18\x02 \x01(\x0e2\x0f.ui.StateChangeR\x04type\"\xbd\x03\n" +
	"\aService\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12\x1c\n" +
	"\tnamespace\x18\x03 \x01(\tR\tnamespace\x12\x16\n" +
	"\x06labels\x18\x04 \x03(\tR\x06labels\x12\x1b\n" +
	"\tdns_names\x18\x05 \x03(\tR\bdnsNames\x124\n" +
	"\x16egress_policy_enforced\x18\x06 \x01(\bR\x14egressPolicyEnforced\x126\n" +
	"\x17ingress_policy_enforced\x18\a \x01(\bR\x15ingressPolicyEnforced\x128\n" +
	"\x18visibility_policy_status\x18\b \x01(\tR\x16visibilityPolicyStatus\x12I\n" +
	"\x12creation_timestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\x11creationTimestamp\x12,\n" +
	"\tworkloads\x18\n" +
	" \x03(\v2\x0e.flow.WorkloadR\tworkloads\x12\x1a\n" +
	"\bidentity\x18\f \x01(\rR\bidentity\"Z\n" +
	"\fServiceState\x12%\n" +
	"\aservice\x18\x01 \x01(\v2\v.ui.ServiceR\aservice\x12#\n" +
	"\x04type\x18\x02 \x01(\x0e2\x0f.ui.StateChangeR\x04type\"-\n" +
	"\rServiceFilter\x12\x1c\n" +
	"\tnamespace\x18\x01 \x03(\tR\tnamespace\"\xc8\x04\n" +
	"\vServiceLink\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x1b\n" +
	"\tsource_id\x18\x02 \x01(\tR\bsourceId\x12%\n" +
	"\x0edestination_id\x18\x03 \x01(\tR\rdestinationId\x12)\n" +
	"\x10destination_port\x18\x04 \x01(\rR\x0fdestinationPort\x12/\n" +
	"\vip_protocol\x18\x05 \x01(\x0e2\x0e.ui.IPProtocolR\n" +
	"ipProtocol\x12'\n" +
	"\averdict\x18\x06 \x01(\x0e2\r.flow.VerdictR\averdict\x12\x1f\n" +
	"\vflow_amount\x18\a \x01(\x04R\n" +
	"flowAmount\x121\n" +
	"\alatency\x18\b \x01(\v2\x17.ui.ServiceLink.LatencyR\alatency\x12)\n" +
	"\x10bytes_transfered\x18\t \x01(\x04R\x0fbytesTransfered\x12+\n" +
	"\tauth_type\x18\n" +
	" \x01(\x0e2\x0e.flow.AuthTypeR\bauthType\x12!\n" +
	"\fis_encrypted\x18\v \x01(\bR\visEncrypted\x1a\x90\x01\n" +
	"\aLatency\x12+\n" +
	"\x03min\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\x03min\x12+\n" +
	"\x03max\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\x03max\x12+\n" +
	"\x03avg\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\x03avg\"k\n" +
	"\x10ServiceLinkState\x122\n" +
	"\fservice_link\x18\x01 \x01(\v2\x0f.ui.ServiceLinkR\vserviceLink\x12#\n" +
	"\x04type\x18\x02 \x01(\x0e2\x0f.ui.StateChangeR\x04type\"\xc7\x01\n" +
	"\x11ServiceLinkFilter\x12)\n" +
	"\x06source\x18\x01 \x03(\v2\x11.ui.ServiceFilterR\x06source\x123\n" +
	"\vdestination\x18\x02 \x03(\v2\x11.ui.ServiceFilterR\vdestination\x12)\n" +
	"\x10destination_port\x18\x03 \x03(\tR\x0fdestinationPort\x12'\n" +
	"\averdict\x18\x04 \x03(\x0e2\r.flow.VerdictR\averdict\"\x19\n" +
	"\x17GetControlStreamRequest\"\xf2\x01\n" +
	"\x18GetControlStreamResponse\x12N\n" +
	"\n" +
	"namespaces\x18\x01 \x01(\v2,.ui.GetControlStreamResponse.NamespaceStatesH\x00R\n" +
	"namespaces\x126\n" +
	"\fnotification\x18\x02 \x01(\v2\x10.ui.NotificationH\x00R\fnotification\x1aE\n" +
	"\x0fNamespaceStates\x122\n" +
	"\n" +
	"namespaces\x18\x01 \x03(\v2\x12.ui.NamespaceStateR\n" +
	"namespacesB\a\n" +
	"\x05event*\x83\x01\n" +
	"\tEventType\x12\x11\n" +
	"\rUNKNOWN_EVENT\x10\x00\x12\b\n" +
	"\x04FLOW\x10\x01\x12\x17\n" +
	"\x13K8S_NAMESPACE_STATE\x10\x02\x12\x11\n" +
	"\rSERVICE_STATE\x10\x03\x12\x16\n" +
	"\x12SERVICE_LINK_STATE\x10\x04\x12\t\n" +
	"\x05FLOWS\x10\x05\x12\n" +
	"\n" +
	"\x06STATUS\x10\x06*Q\n" +
	"\n" +
	"IPProtocol\x12\x17\n" +
	"\x13UNKNOWN_IP_PROTOCOL\x10\x00\x12\a\n" +
	"\x03TCP\x10\x01\x12\a\n" +
	"\x03UDP\x10\x02\x12\v\n" +
	"\aICMP_V4\x10\x03\x12\v\n" +
	"\aICMP_V6\x10\x04*Y\n" +
	"\vStateChange\x12\x18\n" +
	"\x14UNKNOWN_STATE_CHANGE\x10\x00\x12\t\n" +
	"\x05ADDED\x10\x01\x12\f\n" +
	"\bMODIFIED\x10\x02\x12\v\n" +
	"\aDELETED\x10\x03\x12\n" +
	"\n" +
	"\x06EXISTS\x10\x042\xcf\x01\n" +
	"\x02UI\x12<\n" +
	"\tGetEvents\x12\x14.ui.GetEventsRequest\x1a\x15.ui.GetEventsResponse\"\x000\x01\x12:\n" +
	"\tGetStatus\x12\x14.ui.GetStatusRequest\x1a\x15.ui.GetStatusResponse\"\x00\x12O\n" +
	"\x10GetControlStream\x12\x1b.ui.GetControlStreamRequest\x1a\x1c.ui.GetControlStreamResponse0\x01b\x06proto3"

var (
	file_ui_ui_proto_rawDescOnce sync.Once
	file_ui_ui_proto_rawDescData []byte
)

func file_ui_ui_proto_rawDescGZIP() []byte {
	file_ui_ui_proto_rawDescOnce.Do(func() {
		file_ui_ui_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ui_ui_proto_rawDesc), len(file_ui_ui_proto_rawDesc)))
	})
	return file_ui_ui_proto_rawDescData
}

var file_ui_ui_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_ui_ui_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
var file_ui_ui_proto_goTypes = []any{
	(EventType)(0),                                   // 0: ui.EventType
	(IPProtocol)(0),                                  // 1: ui.IPProtocol
	(StateChange)(0),                                 // 2: ui.StateChange
	(*GetEventsRequest)(nil),                         // 3: ui.GetEventsRequest
	(*GetEventsResponse)(nil),                        // 4: ui.GetEventsResponse
	(*Event)(nil),                                    // 5: ui.Event
	(*Flows)(nil),                                    // 6: ui.Flows
	(*EventFilter)(nil),                              // 7: ui.EventFilter
	(*NamespaceDescriptor)(nil),                      // 8: ui.NamespaceDescriptor
	(*NamespaceState)(nil),                           // 9: ui.NamespaceState
	(*Service)(nil),                                  // 10: ui.Service
	(*ServiceState)(nil),                             // 11: ui.ServiceState
	(*ServiceFilter)(nil),                            // 12: ui.ServiceFilter
	(*ServiceLink)(nil),                              // 13: ui.ServiceLink
	(*ServiceLinkState)(nil),                         // 14: ui.ServiceLinkState
	(*ServiceLinkFilter)(nil),                        // 15: ui.ServiceLinkFilter
	(*GetControlStreamRequest)(nil),                  // 16: ui.GetControlStreamRequest
	(*GetControlStreamResponse)(nil),                 // 17: ui.GetControlStreamResponse
	(*ServiceLink_Latency)(nil),                      // 18: ui.ServiceLink.Latency
	(*GetControlStreamResponse_NamespaceStates)(nil), // 19: ui.GetControlStreamResponse.NamespaceStates
	(*timestamppb.Timestamp)(nil),                    // 20: google.protobuf.Timestamp
	(*GetStatusRequest)(nil),                         // 21: ui.GetStatusRequest
	(*flow.Flow)(nil),                                // 22: flow.Flow
	(*Notification)(nil),                             // 23: ui.Notification
	(*flow.FlowFilter)(nil),                          // 24: flow.FlowFilter
	(*flow.Workload)(nil),                            // 25: flow.Workload
	(flow.Verdict)(0),                                // 26: flow.Verdict
	(flow.AuthType)(0),                               // 27: flow.AuthType
	(*durationpb.Duration)(nil),                      // 28: google.protobuf.Duration
	(*GetStatusResponse)(nil),                        // 29: ui.GetStatusResponse
}
var file_ui_ui_proto_depIdxs = []int32{
	0,  // 0: ui.GetEventsRequest.event_types:type_name -> ui.EventType
	7,  // 1: ui.GetEventsRequest.blacklist:type_name -> ui.EventFilter
	7,  // 2: ui.GetEventsRequest.whitelist:type_name -> ui.EventFilter
	20, // 3: ui.GetEventsRequest.since:type_name -> google.protobuf.Timestamp
	21, // 4: ui.GetEventsRequest.status_request:type_name -> ui.GetStatusRequest
	20, // 5: ui.GetEventsResponse.timestamp:type_name -> google.protobuf.Timestamp
	5,  // 6: ui.GetEventsResponse.events:type_name -> ui.Event
	22, // 7: ui.Event.flow:type_name -> flow.Flow
	9,  // 8: ui.Event.namespace_state:type_name -> ui.NamespaceState
	11, // 9: ui.Event.service_state:type_name -> ui.ServiceState
	14, // 10: ui.Event.service_link_state:type_name -> ui.ServiceLinkState
	6,  // 11: ui.Event.flows:type_name -> ui.Flows
	23, // 12: ui.Event.notification:type_name -> ui.Notification
	22, // 13: ui.Flows.flows:type_name -> flow.Flow
	24, // 14: ui.EventFilter.flow_filter:type_name -> flow.FlowFilter
	12, // 15: ui.EventFilter.service_filter:type_name -> ui.ServiceFilter
	15, // 16: ui.EventFilter.service_link_filter:type_name -> ui.ServiceLinkFilter
	20, // 17: ui.NamespaceDescriptor.creation_timestamp:type_name -> google.protobuf.Timestamp
	8,  // 18: ui.NamespaceState.namespace:type_name -> ui.NamespaceDescriptor
	2,  // 19: ui.NamespaceState.type:type_name -> ui.StateChange
	20, // 20: ui.Service.creation_timestamp:type_name -> google.protobuf.Timestamp
	25, // 21: ui.Service.workloads:type_name -> flow.Workload
	10, // 22: ui.ServiceState.service:type_name -> ui.Service
	2,  // 23: ui.ServiceState.type:type_name -> ui.StateChange
	1,  // 24: ui.ServiceLink.ip_protocol:type_name -> ui.IPProtocol
	26, // 25: ui.ServiceLink.verdict:type_name -> flow.Verdict
	18, // 26: ui.ServiceLink.latency:type_name -> ui.ServiceLink.Latency
	27, // 27: ui.ServiceLink.auth_type:type_name -> flow.AuthType
	13, // 28: ui.ServiceLinkState.service_link:type_name -> ui.ServiceLink
	2,  // 29: ui.ServiceLinkState.type:type_name -> ui.StateChange
	12, // 30: ui.ServiceLinkFilter.source:type_name -> ui.ServiceFilter
	12, // 31: ui.ServiceLinkFilter.destination:type_name -> ui.ServiceFilter
	26, // 32: ui.ServiceLinkFilter.verdict:type_name -> flow.Verdict
	19, // 33: ui.GetControlStreamResponse.namespaces:type_name -> ui.GetControlStreamResponse.NamespaceStates
	23, // 34: ui.GetControlStreamResponse.notification:type_name -> ui.Notification
	28, // 35: ui.ServiceLink.Latency.min:type_name -> google.protobuf.Duration
	28, // 36: ui.ServiceLink.Latency.max:type_name -> google.protobuf.Duration
	28, // 37: ui.ServiceLink.Latency.avg:type_name -> google.protobuf.Duration
	9,  // 38: ui.GetControlStreamResponse.NamespaceStates.namespaces:type_name -> ui.NamespaceState
	3,  // 39: ui.UI.GetEvents:input_type -> ui.GetEventsRequest
	21, // 40: ui.UI.GetStatus:input_type -> ui.GetStatusRequest
	16, // 41: ui.UI.GetControlStream:input_type -> ui.GetControlStreamRequest
	4,  // 42: ui.UI.GetEvents:output_type -> ui.GetEventsResponse
	29, // 43: ui.UI.GetStatus:output_type -> ui.GetStatusResponse
	17, // 44: ui.UI.GetControlStream:output_type -> ui.GetControlStreamResponse
	42, // [42:45] is the sub-list for method output_type
	39, // [39:42] is the sub-list for method input_type
	39, // [39:39] is the sub-list for extension type_name
	39, // [39:39] is the sub-list for extension extendee
	0,  // [0:39] is the sub-list for field type_name
}

func init() { file_ui_ui_proto_init() }
func file_ui_ui_proto_init() {
	if File_ui_ui_proto != nil {
		return
	}
	file_ui_notifications_proto_init()
	file_ui_status_proto_init()
	file_ui_ui_proto_msgTypes[2].OneofWrappers = []any{
		(*Event_Flow)(nil),
		(*Event_NamespaceState)(nil),
		(*Event_ServiceState)(nil),
		(*Event_ServiceLinkState)(nil),
		(*Event_Flows)(nil),
		(*Event_Notification)(nil),
	}
	file_ui_ui_proto_msgTypes[4].OneofWrappers = []any{
		(*EventFilter_FlowFilter)(nil),
		(*EventFilter_ServiceFilter)(nil),
		(*EventFilter_ServiceLinkFilter)(nil),
	}
	file_ui_ui_proto_msgTypes[14].OneofWrappers = []any{
		(*GetControlStreamResponse_Namespaces)(nil),
		(*GetControlStreamResponse_Notification)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_ui_ui_proto_rawDesc), len(file_ui_ui_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   17,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_ui_ui_proto_goTypes,
		DependencyIndexes: file_ui_ui_proto_depIdxs,
		EnumInfos:         file_ui_ui_proto_enumTypes,
		MessageInfos:      file_ui_ui_proto_msgTypes,
	}.Build()
	File_ui_ui_proto = out.File
	file_ui_ui_proto_goTypes = nil
	file_ui_ui_proto_depIdxs = nil
}
