linkerd2-proxy-api 0.18.0

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.30.2
// source: tap.proto

package tap

import (
	duration "github.com/golang/protobuf/ptypes/duration"
	http_types "github.com/linkerd/linkerd2-proxy-api/go/http_types"
	net "github.com/linkerd/linkerd2-proxy-api/go/net"
	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)
)

type TapEvent_ProxyDirection int32

const (
	TapEvent_UNKNOWN  TapEvent_ProxyDirection = 0
	TapEvent_INBOUND  TapEvent_ProxyDirection = 1
	TapEvent_OUTBOUND TapEvent_ProxyDirection = 2
)

// Enum value maps for TapEvent_ProxyDirection.
var (
	TapEvent_ProxyDirection_name = map[int32]string{
		0: "UNKNOWN",
		1: "INBOUND",
		2: "OUTBOUND",
	}
	TapEvent_ProxyDirection_value = map[string]int32{
		"UNKNOWN":  0,
		"INBOUND":  1,
		"OUTBOUND": 2,
	}
)

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

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

func (TapEvent_ProxyDirection) Descriptor() protoreflect.EnumDescriptor {
	return file_tap_proto_enumTypes[0].Descriptor()
}

func (TapEvent_ProxyDirection) Type() protoreflect.EnumType {
	return &file_tap_proto_enumTypes[0]
}

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

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

type ObserveRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Limits the number of event keys that will be returned by this tap.
	Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Encodes request-matching logic.
	Match *ObserveRequest_Match `protobuf:"bytes,2,opt,name=match,proto3" json:"match,omitempty"`
	// Conditionally extracts components from requests and responses to include
	// in tap events
	Extract       *ObserveRequest_Extract `protobuf:"bytes,3,opt,name=extract,proto3" json:"extract,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest) ProtoMessage() {}

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

func (x *ObserveRequest) GetLimit() uint32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

func (x *ObserveRequest) GetMatch() *ObserveRequest_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *ObserveRequest) GetExtract() *ObserveRequest_Extract {
	if x != nil {
		return x.Extract
	}
	return nil
}

type Eos struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to End:
	//
	//	*Eos_GrpcStatusCode
	//	*Eos_ResetErrorCode
	End           isEos_End `protobuf_oneof:"end"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Eos) ProtoMessage() {}

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

func (x *Eos) GetEnd() isEos_End {
	if x != nil {
		return x.End
	}
	return nil
}

func (x *Eos) GetGrpcStatusCode() uint32 {
	if x != nil {
		if x, ok := x.End.(*Eos_GrpcStatusCode); ok {
			return x.GrpcStatusCode
		}
	}
	return 0
}

func (x *Eos) GetResetErrorCode() uint32 {
	if x != nil {
		if x, ok := x.End.(*Eos_ResetErrorCode); ok {
			return x.ResetErrorCode
		}
	}
	return 0
}

type isEos_End interface {
	isEos_End()
}

type Eos_GrpcStatusCode struct {
	GrpcStatusCode uint32 `protobuf:"varint,1,opt,name=grpc_status_code,json=grpcStatusCode,proto3,oneof"`
}

type Eos_ResetErrorCode struct {
	ResetErrorCode uint32 `protobuf:"varint,2,opt,name=reset_error_code,json=resetErrorCode,proto3,oneof"`
}

func (*Eos_GrpcStatusCode) isEos_End() {}

func (*Eos_ResetErrorCode) isEos_End() {}

type TapEvent struct {
	state           protoimpl.MessageState  `protogen:"open.v1"`
	Source          *net.TcpAddress         `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	SourceMeta      *TapEvent_EndpointMeta  `protobuf:"bytes,5,opt,name=source_meta,json=sourceMeta,proto3" json:"source_meta,omitempty"`
	RouteMeta       *TapEvent_RouteMeta     `protobuf:"bytes,7,opt,name=route_meta,json=routeMeta,proto3" json:"route_meta,omitempty"`
	Destination     *net.TcpAddress         `protobuf:"bytes,2,opt,name=destination,proto3" json:"destination,omitempty"`
	DestinationMeta *TapEvent_EndpointMeta  `protobuf:"bytes,4,opt,name=destination_meta,json=destinationMeta,proto3" json:"destination_meta,omitempty"`
	ProxyDirection  TapEvent_ProxyDirection `protobuf:"varint,6,opt,name=proxy_direction,json=proxyDirection,proto3,enum=io.linkerd.proxy.tap.TapEvent_ProxyDirection" json:"proxy_direction,omitempty"`
	// Types that are valid to be assigned to Event:
	//
	//	*TapEvent_Http_
	Event         isTapEvent_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TapEvent) ProtoMessage() {}

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

func (x *TapEvent) GetSource() *net.TcpAddress {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *TapEvent) GetSourceMeta() *TapEvent_EndpointMeta {
	if x != nil {
		return x.SourceMeta
	}
	return nil
}

func (x *TapEvent) GetRouteMeta() *TapEvent_RouteMeta {
	if x != nil {
		return x.RouteMeta
	}
	return nil
}

func (x *TapEvent) GetDestination() *net.TcpAddress {
	if x != nil {
		return x.Destination
	}
	return nil
}

func (x *TapEvent) GetDestinationMeta() *TapEvent_EndpointMeta {
	if x != nil {
		return x.DestinationMeta
	}
	return nil
}

func (x *TapEvent) GetProxyDirection() TapEvent_ProxyDirection {
	if x != nil {
		return x.ProxyDirection
	}
	return TapEvent_UNKNOWN
}

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

func (x *TapEvent) GetHttp() *TapEvent_Http {
	if x != nil {
		if x, ok := x.Event.(*TapEvent_Http_); ok {
			return x.Http
		}
	}
	return nil
}

type isTapEvent_Event interface {
	isTapEvent_Event()
}

type TapEvent_Http_ struct {
	Http *TapEvent_Http `protobuf:"bytes,3,opt,name=http,proto3,oneof"`
}

func (*TapEvent_Http_) isTapEvent_Event() {}

type ObserveRequest_Match struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Match:
	//
	//	*ObserveRequest_Match_All
	//	*ObserveRequest_Match_Any
	//	*ObserveRequest_Match_Not
	//	*ObserveRequest_Match_Source
	//	*ObserveRequest_Match_Destination
	//	*ObserveRequest_Match_Http_
	//	*ObserveRequest_Match_DestinationLabel
	//	*ObserveRequest_Match_RouteLabel
	Match         isObserveRequest_Match_Match `protobuf_oneof:"match"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match) ProtoMessage() {}

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

func (x *ObserveRequest_Match) GetMatch() isObserveRequest_Match_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *ObserveRequest_Match) GetAll() *ObserveRequest_Match_Seq {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_All); ok {
			return x.All
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetAny() *ObserveRequest_Match_Seq {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Any); ok {
			return x.Any
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetNot() *ObserveRequest_Match {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Not); ok {
			return x.Not
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetSource() *ObserveRequest_Match_Tcp {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Source); ok {
			return x.Source
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetDestination() *ObserveRequest_Match_Tcp {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Destination); ok {
			return x.Destination
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetHttp() *ObserveRequest_Match_Http {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_); ok {
			return x.Http
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetDestinationLabel() *ObserveRequest_Match_Label {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_DestinationLabel); ok {
			return x.DestinationLabel
		}
	}
	return nil
}

func (x *ObserveRequest_Match) GetRouteLabel() *ObserveRequest_Match_Label {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_RouteLabel); ok {
			return x.RouteLabel
		}
	}
	return nil
}

type isObserveRequest_Match_Match interface {
	isObserveRequest_Match_Match()
}

type ObserveRequest_Match_All struct {
	All *ObserveRequest_Match_Seq `protobuf:"bytes,1,opt,name=all,proto3,oneof"`
}

type ObserveRequest_Match_Any struct {
	Any *ObserveRequest_Match_Seq `protobuf:"bytes,2,opt,name=any,proto3,oneof"`
}

type ObserveRequest_Match_Not struct {
	Not *ObserveRequest_Match `protobuf:"bytes,3,opt,name=not,proto3,oneof"`
}

type ObserveRequest_Match_Source struct {
	Source *ObserveRequest_Match_Tcp `protobuf:"bytes,4,opt,name=source,proto3,oneof"`
}

type ObserveRequest_Match_Destination struct {
	Destination *ObserveRequest_Match_Tcp `protobuf:"bytes,5,opt,name=destination,proto3,oneof"`
}

type ObserveRequest_Match_Http_ struct {
	Http *ObserveRequest_Match_Http `protobuf:"bytes,6,opt,name=http,proto3,oneof"`
}

type ObserveRequest_Match_DestinationLabel struct {
	DestinationLabel *ObserveRequest_Match_Label `protobuf:"bytes,7,opt,name=destination_label,json=destinationLabel,proto3,oneof"`
}

type ObserveRequest_Match_RouteLabel struct {
	RouteLabel *ObserveRequest_Match_Label `protobuf:"bytes,8,opt,name=route_label,json=routeLabel,proto3,oneof"`
}

func (*ObserveRequest_Match_All) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_Any) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_Not) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_Source) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_Destination) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_Http_) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_DestinationLabel) isObserveRequest_Match_Match() {}

func (*ObserveRequest_Match_RouteLabel) isObserveRequest_Match_Match() {}

type ObserveRequest_Extract struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Extract:
	//
	//	*ObserveRequest_Extract_Http_
	Extract       isObserveRequest_Extract_Extract `protobuf_oneof:"extract"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Extract) ProtoMessage() {}

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

func (x *ObserveRequest_Extract) GetExtract() isObserveRequest_Extract_Extract {
	if x != nil {
		return x.Extract
	}
	return nil
}

func (x *ObserveRequest_Extract) GetHttp() *ObserveRequest_Extract_Http {
	if x != nil {
		if x, ok := x.Extract.(*ObserveRequest_Extract_Http_); ok {
			return x.Http
		}
	}
	return nil
}

type isObserveRequest_Extract_Extract interface {
	isObserveRequest_Extract_Extract()
}

type ObserveRequest_Extract_Http_ struct {
	Http *ObserveRequest_Extract_Http `protobuf:"bytes,1,opt,name=http,proto3,oneof"`
}

func (*ObserveRequest_Extract_Http_) isObserveRequest_Extract_Extract() {}

type ObserveRequest_Match_Seq struct {
	state         protoimpl.MessageState  `protogen:"open.v1"`
	Matches       []*ObserveRequest_Match `protobuf:"bytes,1,rep,name=matches,proto3" json:"matches,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Seq) ProtoMessage() {}

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

func (x *ObserveRequest_Match_Seq) GetMatches() []*ObserveRequest_Match {
	if x != nil {
		return x.Matches
	}
	return nil
}

type ObserveRequest_Match_Label struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         string                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Label) ProtoMessage() {}

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

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

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

type ObserveRequest_Match_Tcp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Match:
	//
	//	*ObserveRequest_Match_Tcp_Netmask_
	//	*ObserveRequest_Match_Tcp_Ports
	Match         isObserveRequest_Match_Tcp_Match `protobuf_oneof:"match"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Tcp) ProtoMessage() {}

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

func (x *ObserveRequest_Match_Tcp) GetMatch() isObserveRequest_Match_Tcp_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *ObserveRequest_Match_Tcp) GetNetmask() *ObserveRequest_Match_Tcp_Netmask {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Tcp_Netmask_); ok {
			return x.Netmask
		}
	}
	return nil
}

func (x *ObserveRequest_Match_Tcp) GetPorts() *ObserveRequest_Match_Tcp_PortRange {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Tcp_Ports); ok {
			return x.Ports
		}
	}
	return nil
}

type isObserveRequest_Match_Tcp_Match interface {
	isObserveRequest_Match_Tcp_Match()
}

type ObserveRequest_Match_Tcp_Netmask_ struct {
	Netmask *ObserveRequest_Match_Tcp_Netmask `protobuf:"bytes,1,opt,name=netmask,proto3,oneof"`
}

type ObserveRequest_Match_Tcp_Ports struct {
	Ports *ObserveRequest_Match_Tcp_PortRange `protobuf:"bytes,3,opt,name=ports,proto3,oneof"`
}

func (*ObserveRequest_Match_Tcp_Netmask_) isObserveRequest_Match_Tcp_Match() {}

func (*ObserveRequest_Match_Tcp_Ports) isObserveRequest_Match_Tcp_Match() {}

type ObserveRequest_Match_Http struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Match:
	//
	//	*ObserveRequest_Match_Http_Scheme
	//	*ObserveRequest_Match_Http_Method
	//	*ObserveRequest_Match_Http_Authority
	//	*ObserveRequest_Match_Http_Path
	Match         isObserveRequest_Match_Http_Match `protobuf_oneof:"match"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Http) ProtoMessage() {}

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

func (x *ObserveRequest_Match_Http) GetMatch() isObserveRequest_Match_Http_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *ObserveRequest_Match_Http) GetScheme() *http_types.Scheme {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_Scheme); ok {
			return x.Scheme
		}
	}
	return nil
}

func (x *ObserveRequest_Match_Http) GetMethod() *http_types.HttpMethod {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_Method); ok {
			return x.Method
		}
	}
	return nil
}

func (x *ObserveRequest_Match_Http) GetAuthority() *ObserveRequest_Match_Http_StringMatch {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_Authority); ok {
			return x.Authority
		}
	}
	return nil
}

func (x *ObserveRequest_Match_Http) GetPath() *ObserveRequest_Match_Http_StringMatch {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_Path); ok {
			return x.Path
		}
	}
	return nil
}

type isObserveRequest_Match_Http_Match interface {
	isObserveRequest_Match_Http_Match()
}

type ObserveRequest_Match_Http_Scheme struct {
	Scheme *http_types.Scheme `protobuf:"bytes,1,opt,name=scheme,proto3,oneof"`
}

type ObserveRequest_Match_Http_Method struct {
	Method *http_types.HttpMethod `protobuf:"bytes,3,opt,name=method,proto3,oneof"`
}

type ObserveRequest_Match_Http_Authority struct {
	Authority *ObserveRequest_Match_Http_StringMatch `protobuf:"bytes,2,opt,name=authority,proto3,oneof"`
}

type ObserveRequest_Match_Http_Path struct {
	Path *ObserveRequest_Match_Http_StringMatch `protobuf:"bytes,4,opt,name=path,proto3,oneof"` // TODO Header        header    = 4;
}

func (*ObserveRequest_Match_Http_Scheme) isObserveRequest_Match_Http_Match() {}

func (*ObserveRequest_Match_Http_Method) isObserveRequest_Match_Http_Match() {}

func (*ObserveRequest_Match_Http_Authority) isObserveRequest_Match_Http_Match() {}

func (*ObserveRequest_Match_Http_Path) isObserveRequest_Match_Http_Match() {}

type ObserveRequest_Match_Tcp_Netmask struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ip            *net.IPAddress         `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Mask          uint32                 `protobuf:"varint,2,opt,name=mask,proto3" json:"mask,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Tcp_Netmask) ProtoMessage() {}

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

func (x *ObserveRequest_Match_Tcp_Netmask) GetIp() *net.IPAddress {
	if x != nil {
		return x.Ip
	}
	return nil
}

func (x *ObserveRequest_Match_Tcp_Netmask) GetMask() uint32 {
	if x != nil {
		return x.Mask
	}
	return 0
}

// If either a minimum or maximum is not specified, the range is
// considered to be over a discrete value.
type ObserveRequest_Match_Tcp_PortRange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Minimum matching port value (inclusive), if specified.
	Min uint32 `protobuf:"varint,1,opt,name=min,proto3" json:"min,omitempty"`
	// Maximum matching port value (inclusive), if specified.
	Max           uint32 `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Tcp_PortRange) ProtoMessage() {}

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

func (x *ObserveRequest_Match_Tcp_PortRange) GetMin() uint32 {
	if x != nil {
		return x.Min
	}
	return 0
}

func (x *ObserveRequest_Match_Tcp_PortRange) GetMax() uint32 {
	if x != nil {
		return x.Max
	}
	return 0
}

type ObserveRequest_Match_Http_StringMatch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Match:
	//
	//	*ObserveRequest_Match_Http_StringMatch_Exact
	//	*ObserveRequest_Match_Http_StringMatch_Prefix
	Match         isObserveRequest_Match_Http_StringMatch_Match `protobuf_oneof:"match"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Match_Http_StringMatch) ProtoMessage() {}

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

func (x *ObserveRequest_Match_Http_StringMatch) GetMatch() isObserveRequest_Match_Http_StringMatch_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *ObserveRequest_Match_Http_StringMatch) GetExact() string {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_StringMatch_Exact); ok {
			return x.Exact
		}
	}
	return ""
}

func (x *ObserveRequest_Match_Http_StringMatch) GetPrefix() string {
	if x != nil {
		if x, ok := x.Match.(*ObserveRequest_Match_Http_StringMatch_Prefix); ok {
			return x.Prefix
		}
	}
	return ""
}

type isObserveRequest_Match_Http_StringMatch_Match interface {
	isObserveRequest_Match_Http_StringMatch_Match()
}

type ObserveRequest_Match_Http_StringMatch_Exact struct {
	Exact string `protobuf:"bytes,1,opt,name=exact,proto3,oneof"`
}

type ObserveRequest_Match_Http_StringMatch_Prefix struct {
	Prefix string `protobuf:"bytes,2,opt,name=prefix,proto3,oneof"`
}

func (*ObserveRequest_Match_Http_StringMatch_Exact) isObserveRequest_Match_Http_StringMatch_Match() {}

func (*ObserveRequest_Match_Http_StringMatch_Prefix) isObserveRequest_Match_Http_StringMatch_Match() {
}

type ObserveRequest_Extract_Http struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Extract:
	//
	//	*ObserveRequest_Extract_Http_Headers_
	Extract       isObserveRequest_Extract_Http_Extract `protobuf_oneof:"extract"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObserveRequest_Extract_Http) ProtoMessage() {}

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

func (x *ObserveRequest_Extract_Http) GetExtract() isObserveRequest_Extract_Http_Extract {
	if x != nil {
		return x.Extract
	}
	return nil
}

func (x *ObserveRequest_Extract_Http) GetHeaders() *ObserveRequest_Extract_Http_Headers {
	if x != nil {
		if x, ok := x.Extract.(*ObserveRequest_Extract_Http_Headers_); ok {
			return x.Headers
		}
	}
	return nil
}

type isObserveRequest_Extract_Http_Extract interface {
	isObserveRequest_Extract_Http_Extract()
}

type ObserveRequest_Extract_Http_Headers_ struct {
	Headers *ObserveRequest_Extract_Http_Headers `protobuf:"bytes,1,opt,name=headers,proto3,oneof"`
}

func (*ObserveRequest_Extract_Http_Headers_) isObserveRequest_Extract_Http_Extract() {}

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

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

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

func (*ObserveRequest_Extract_Http_Headers) ProtoMessage() {}

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

type TapEvent_EndpointMeta struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Labels        map[string]string      `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TapEvent_EndpointMeta) ProtoMessage() {}

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

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

type TapEvent_RouteMeta struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Labels        map[string]string      `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TapEvent_RouteMeta) ProtoMessage() {}

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

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

type TapEvent_Http struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*TapEvent_Http_RequestInit_
	//	*TapEvent_Http_ResponseInit_
	//	*TapEvent_Http_ResponseEnd_
	Event         isTapEvent_Http_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TapEvent_Http) ProtoMessage() {}

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

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

func (x *TapEvent_Http) GetRequestInit() *TapEvent_Http_RequestInit {
	if x != nil {
		if x, ok := x.Event.(*TapEvent_Http_RequestInit_); ok {
			return x.RequestInit
		}
	}
	return nil
}

func (x *TapEvent_Http) GetResponseInit() *TapEvent_Http_ResponseInit {
	if x != nil {
		if x, ok := x.Event.(*TapEvent_Http_ResponseInit_); ok {
			return x.ResponseInit
		}
	}
	return nil
}

func (x *TapEvent_Http) GetResponseEnd() *TapEvent_Http_ResponseEnd {
	if x != nil {
		if x, ok := x.Event.(*TapEvent_Http_ResponseEnd_); ok {
			return x.ResponseEnd
		}
	}
	return nil
}

type isTapEvent_Http_Event interface {
	isTapEvent_Http_Event()
}

type TapEvent_Http_RequestInit_ struct {
	RequestInit *TapEvent_Http_RequestInit `protobuf:"bytes,1,opt,name=request_init,json=requestInit,proto3,oneof"`
}

type TapEvent_Http_ResponseInit_ struct {
	ResponseInit *TapEvent_Http_ResponseInit `protobuf:"bytes,2,opt,name=response_init,json=responseInit,proto3,oneof"`
}

type TapEvent_Http_ResponseEnd_ struct {
	ResponseEnd *TapEvent_Http_ResponseEnd `protobuf:"bytes,3,opt,name=response_end,json=responseEnd,proto3,oneof"`
}

func (*TapEvent_Http_RequestInit_) isTapEvent_Http_Event() {}

func (*TapEvent_Http_ResponseInit_) isTapEvent_Http_Event() {}

func (*TapEvent_Http_ResponseEnd_) isTapEvent_Http_Event() {}

type TapEvent_Http_StreamId struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A randomized base (stable across a process's runtime)
	Base uint32 `protobuf:"varint,1,opt,name=base,proto3" json:"base,omitempty"`
	// A stream id unique within the lifetime of `base`.
	Stream        uint64 `protobuf:"varint,2,opt,name=stream,proto3" json:"stream,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TapEvent_Http_StreamId) Reset() {
	*x = TapEvent_Http_StreamId{}
	mi := &file_tap_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapEvent_Http_StreamId) ProtoMessage() {}

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

func (x *TapEvent_Http_StreamId) GetBase() uint32 {
	if x != nil {
		return x.Base
	}
	return 0
}

func (x *TapEvent_Http_StreamId) GetStream() uint64 {
	if x != nil {
		return x.Stream
	}
	return 0
}

type TapEvent_Http_RequestInit struct {
	state         protoimpl.MessageState  `protogen:"open.v1"`
	Id            *TapEvent_Http_StreamId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Method        *http_types.HttpMethod  `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
	Scheme        *http_types.Scheme      `protobuf:"bytes,3,opt,name=scheme,proto3" json:"scheme,omitempty"`
	Authority     string                  `protobuf:"bytes,4,opt,name=authority,proto3" json:"authority,omitempty"`
	Path          string                  `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	Headers       *http_types.Headers     `protobuf:"bytes,6,opt,name=headers,proto3" json:"headers,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TapEvent_Http_RequestInit) Reset() {
	*x = TapEvent_Http_RequestInit{}
	mi := &file_tap_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapEvent_Http_RequestInit) ProtoMessage() {}

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

func (x *TapEvent_Http_RequestInit) GetId() *TapEvent_Http_StreamId {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *TapEvent_Http_RequestInit) GetMethod() *http_types.HttpMethod {
	if x != nil {
		return x.Method
	}
	return nil
}

func (x *TapEvent_Http_RequestInit) GetScheme() *http_types.Scheme {
	if x != nil {
		return x.Scheme
	}
	return nil
}

func (x *TapEvent_Http_RequestInit) GetAuthority() string {
	if x != nil {
		return x.Authority
	}
	return ""
}

func (x *TapEvent_Http_RequestInit) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *TapEvent_Http_RequestInit) GetHeaders() *http_types.Headers {
	if x != nil {
		return x.Headers
	}
	return nil
}

type TapEvent_Http_ResponseInit struct {
	state            protoimpl.MessageState  `protogen:"open.v1"`
	Id               *TapEvent_Http_StreamId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SinceRequestInit *duration.Duration      `protobuf:"bytes,2,opt,name=since_request_init,json=sinceRequestInit,proto3" json:"since_request_init,omitempty"`
	HttpStatus       uint32                  `protobuf:"varint,3,opt,name=http_status,json=httpStatus,proto3" json:"http_status,omitempty"`
	Headers          *http_types.Headers     `protobuf:"bytes,4,opt,name=headers,proto3" json:"headers,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *TapEvent_Http_ResponseInit) Reset() {
	*x = TapEvent_Http_ResponseInit{}
	mi := &file_tap_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapEvent_Http_ResponseInit) ProtoMessage() {}

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

func (x *TapEvent_Http_ResponseInit) GetId() *TapEvent_Http_StreamId {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *TapEvent_Http_ResponseInit) GetSinceRequestInit() *duration.Duration {
	if x != nil {
		return x.SinceRequestInit
	}
	return nil
}

func (x *TapEvent_Http_ResponseInit) GetHttpStatus() uint32 {
	if x != nil {
		return x.HttpStatus
	}
	return 0
}

func (x *TapEvent_Http_ResponseInit) GetHeaders() *http_types.Headers {
	if x != nil {
		return x.Headers
	}
	return nil
}

type TapEvent_Http_ResponseEnd struct {
	state             protoimpl.MessageState  `protogen:"open.v1"`
	Id                *TapEvent_Http_StreamId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SinceRequestInit  *duration.Duration      `protobuf:"bytes,2,opt,name=since_request_init,json=sinceRequestInit,proto3" json:"since_request_init,omitempty"`
	SinceResponseInit *duration.Duration      `protobuf:"bytes,3,opt,name=since_response_init,json=sinceResponseInit,proto3" json:"since_response_init,omitempty"`
	ResponseBytes     uint64                  `protobuf:"varint,4,opt,name=response_bytes,json=responseBytes,proto3" json:"response_bytes,omitempty"`
	Eos               *Eos                    `protobuf:"bytes,5,opt,name=eos,proto3" json:"eos,omitempty"`
	Trailers          *http_types.Headers     `protobuf:"bytes,6,opt,name=trailers,proto3" json:"trailers,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *TapEvent_Http_ResponseEnd) Reset() {
	*x = TapEvent_Http_ResponseEnd{}
	mi := &file_tap_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapEvent_Http_ResponseEnd) ProtoMessage() {}

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

func (x *TapEvent_Http_ResponseEnd) GetId() *TapEvent_Http_StreamId {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *TapEvent_Http_ResponseEnd) GetSinceRequestInit() *duration.Duration {
	if x != nil {
		return x.SinceRequestInit
	}
	return nil
}

func (x *TapEvent_Http_ResponseEnd) GetSinceResponseInit() *duration.Duration {
	if x != nil {
		return x.SinceResponseInit
	}
	return nil
}

func (x *TapEvent_Http_ResponseEnd) GetResponseBytes() uint64 {
	if x != nil {
		return x.ResponseBytes
	}
	return 0
}

func (x *TapEvent_Http_ResponseEnd) GetEos() *Eos {
	if x != nil {
		return x.Eos
	}
	return nil
}

func (x *TapEvent_Http_ResponseEnd) GetTrailers() *http_types.Headers {
	if x != nil {
		return x.Trailers
	}
	return nil
}

var File_tap_proto protoreflect.FileDescriptor

const file_tap_proto_rawDesc = "" +
	"\n" +
	"\ttap.proto\x12\x14io.linkerd.proxy.tap\x1a\x1egoogle/protobuf/duration.proto\x1a\x10http_types.proto\x1a\tnet.proto\"\xbf\x0e\n" +
	"\x0eObserveRequest\x12\x14\n" +
	"\x05limit\x18\x01 \x01(\rR\x05limit\x12@\n" +
	"\x05match\x18\x02 \x01(\v2*.io.linkerd.proxy.tap.ObserveRequest.MatchR\x05match\x12F\n" +
	"\aextract\x18\x03 \x01(\v2,.io.linkerd.proxy.tap.ObserveRequest.ExtractR\aextract\x1a\xb7\v\n" +
	"\x05Match\x12B\n" +
	"\x03all\x18\x01 \x01(\v2..io.linkerd.proxy.tap.ObserveRequest.Match.SeqH\x00R\x03all\x12B\n" +
	"\x03any\x18\x02 \x01(\v2..io.linkerd.proxy.tap.ObserveRequest.Match.SeqH\x00R\x03any\x12>\n" +
	"\x03not\x18\x03 \x01(\v2*.io.linkerd.proxy.tap.ObserveRequest.MatchH\x00R\x03not\x12H\n" +
	"\x06source\x18\x04 \x01(\v2..io.linkerd.proxy.tap.ObserveRequest.Match.TcpH\x00R\x06source\x12R\n" +
	"\vdestination\x18\x05 \x01(\v2..io.linkerd.proxy.tap.ObserveRequest.Match.TcpH\x00R\vdestination\x12E\n" +
	"\x04http\x18\x06 \x01(\v2/.io.linkerd.proxy.tap.ObserveRequest.Match.HttpH\x00R\x04http\x12_\n" +
	"\x11destination_label\x18\a \x01(\v20.io.linkerd.proxy.tap.ObserveRequest.Match.LabelH\x00R\x10destinationLabel\x12S\n" +
	"\vroute_label\x18\b \x01(\v20.io.linkerd.proxy.tap.ObserveRequest.Match.LabelH\x00R\n" +
	"routeLabel\x1aK\n" +
	"\x03Seq\x12D\n" +
	"\amatches\x18\x01 \x03(\v2*.io.linkerd.proxy.tap.ObserveRequest.MatchR\amatches\x1a/\n" +
	"\x05Label\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value\x1a\xb5\x02\n" +
	"\x03Tcp\x12R\n" +
	"\anetmask\x18\x01 \x01(\v26.io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.NetmaskH\x00R\anetmask\x12P\n" +
	"\x05ports\x18\x03 \x01(\v28.io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.PortRangeH\x00R\x05ports\x1aN\n" +
	"\aNetmask\x12/\n" +
	"\x02ip\x18\x01 \x01(\v2\x1f.io.linkerd.proxy.net.IPAddressR\x02ip\x12\x12\n" +
	"\x04mask\x18\x02 \x01(\rR\x04mask\x1a/\n" +
	"\tPortRange\x12\x10\n" +
	"\x03min\x18\x01 \x01(\rR\x03min\x12\x10\n" +
	"\x03max\x18\x02 \x01(\rR\x03maxB\a\n" +
	"\x05match\x1a\x8b\x03\n" +
	"\x04Http\x12=\n" +
	"\x06scheme\x18\x01 \x01(\v2#.io.linkerd.proxy.http_types.SchemeH\x00R\x06scheme\x12A\n" +
	"\x06method\x18\x03 \x01(\v2'.io.linkerd.proxy.http_types.HttpMethodH\x00R\x06method\x12[\n" +
	"\tauthority\x18\x02 \x01(\v2;.io.linkerd.proxy.tap.ObserveRequest.Match.Http.StringMatchH\x00R\tauthority\x12Q\n" +
	"\x04path\x18\x04 \x01(\v2;.io.linkerd.proxy.tap.ObserveRequest.Match.Http.StringMatchH\x00R\x04path\x1aH\n" +
	"\vStringMatch\x12\x16\n" +
	"\x05exact\x18\x01 \x01(\tH\x00R\x05exact\x12\x18\n" +
	"\x06prefix\x18\x02 \x01(\tH\x00R\x06prefixB\a\n" +
	"\x05matchB\a\n" +
	"\x05matchB\a\n" +
	"\x05match\x1a\xd2\x01\n" +
	"\aExtract\x12G\n" +
	"\x04http\x18\x01 \x01(\v21.io.linkerd.proxy.tap.ObserveRequest.Extract.HttpH\x00R\x04http\x1as\n" +
	"\x04Http\x12U\n" +
	"\aheaders\x18\x01 \x01(\v29.io.linkerd.proxy.tap.ObserveRequest.Extract.Http.HeadersH\x00R\aheaders\x1a\t\n" +
	"\aHeadersB\t\n" +
	"\aextractB\t\n" +
	"\aextract\"d\n" +
	"\x03Eos\x12*\n" +
	"\x10grpc_status_code\x18\x01 \x01(\rH\x00R\x0egrpcStatusCode\x12*\n" +
	"\x10reset_error_code\x18\x02 \x01(\rH\x00R\x0eresetErrorCodeB\x05\n" +
	"\x03end\"\xff\x10\n" +
	"\bTapEvent\x128\n" +
	"\x06source\x18\x01 \x01(\v2 .io.linkerd.proxy.net.TcpAddressR\x06source\x12L\n" +
	"\vsource_meta\x18\x05 \x01(\v2+.io.linkerd.proxy.tap.TapEvent.EndpointMetaR\n" +
	"sourceMeta\x12G\n" +
	"\n" +
	"route_meta\x18\a \x01(\v2(.io.linkerd.proxy.tap.TapEvent.RouteMetaR\trouteMeta\x12B\n" +
	"\vdestination\x18\x02 \x01(\v2 .io.linkerd.proxy.net.TcpAddressR\vdestination\x12V\n" +
	"\x10destination_meta\x18\x04 \x01(\v2+.io.linkerd.proxy.tap.TapEvent.EndpointMetaR\x0fdestinationMeta\x12V\n" +
	"\x0fproxy_direction\x18\x06 \x01(\x0e2-.io.linkerd.proxy.tap.TapEvent.ProxyDirectionR\x0eproxyDirection\x129\n" +
	"\x04http\x18\x03 \x01(\v2#.io.linkerd.proxy.tap.TapEvent.HttpH\x00R\x04http\x1a\x9a\x01\n" +
	"\fEndpointMeta\x12O\n" +
	"\x06labels\x18\x01 \x03(\v27.io.linkerd.proxy.tap.TapEvent.EndpointMeta.LabelsEntryR\x06labels\x1a9\n" +
	"\vLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a\x94\x01\n" +
	"\tRouteMeta\x12L\n" +
	"\x06labels\x18\x01 \x03(\v24.io.linkerd.proxy.tap.TapEvent.RouteMeta.LabelsEntryR\x06labels\x1a9\n" +
	"\vLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a\xfb\t\n" +
	"\x04Http\x12T\n" +
	"\frequest_init\x18\x01 \x01(\v2/.io.linkerd.proxy.tap.TapEvent.Http.RequestInitH\x00R\vrequestInit\x12W\n" +
	"\rresponse_init\x18\x02 \x01(\v20.io.linkerd.proxy.tap.TapEvent.Http.ResponseInitH\x00R\fresponseInit\x12T\n" +
	"\fresponse_end\x18\x03 \x01(\v2/.io.linkerd.proxy.tap.TapEvent.Http.ResponseEndH\x00R\vresponseEnd\x1a6\n" +
	"\bStreamId\x12\x12\n" +
	"\x04base\x18\x01 \x01(\rR\x04base\x12\x16\n" +
	"\x06stream\x18\x02 \x01(\x04R\x06stream\x1a\xbb\x02\n" +
	"\vRequestInit\x12<\n" +
	"\x02id\x18\x01 \x01(\v2,.io.linkerd.proxy.tap.TapEvent.Http.StreamIdR\x02id\x12?\n" +
	"\x06method\x18\x02 \x01(\v2'.io.linkerd.proxy.http_types.HttpMethodR\x06method\x12;\n" +
	"\x06scheme\x18\x03 \x01(\v2#.io.linkerd.proxy.http_types.SchemeR\x06scheme\x12\x1c\n" +
	"\tauthority\x18\x04 \x01(\tR\tauthority\x12\x12\n" +
	"\x04path\x18\x05 \x01(\tR\x04path\x12>\n" +
	"\aheaders\x18\x06 \x01(\v2$.io.linkerd.proxy.http_types.HeadersR\aheaders\x1a\xf6\x01\n" +
	"\fResponseInit\x12<\n" +
	"\x02id\x18\x01 \x01(\v2,.io.linkerd.proxy.tap.TapEvent.Http.StreamIdR\x02id\x12G\n" +
	"\x12since_request_init\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\x10sinceRequestInit\x12\x1f\n" +
	"\vhttp_status\x18\x03 \x01(\rR\n" +
	"httpStatus\x12>\n" +
	"\aheaders\x18\x04 \x01(\v2$.io.linkerd.proxy.http_types.HeadersR\aheaders\x1a\xf5\x02\n" +
	"\vResponseEnd\x12<\n" +
	"\x02id\x18\x01 \x01(\v2,.io.linkerd.proxy.tap.TapEvent.Http.StreamIdR\x02id\x12G\n" +
	"\x12since_request_init\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\x10sinceRequestInit\x12I\n" +
	"\x13since_response_init\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\x11sinceResponseInit\x12%\n" +
	"\x0eresponse_bytes\x18\x04 \x01(\x04R\rresponseBytes\x12+\n" +
	"\x03eos\x18\x05 \x01(\v2\x19.io.linkerd.proxy.tap.EosR\x03eos\x12@\n" +
	"\btrailers\x18\x06 \x01(\v2$.io.linkerd.proxy.http_types.HeadersR\btrailersB\a\n" +
	"\x05event\"8\n" +
	"\x0eProxyDirection\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\v\n" +
	"\aINBOUND\x10\x01\x12\f\n" +
	"\bOUTBOUND\x10\x02B\a\n" +
	"\x05event2Z\n" +
	"\x03Tap\x12S\n" +
	"\aObserve\x12$.io.linkerd.proxy.tap.ObserveRequest\x1a\x1e.io.linkerd.proxy.tap.TapEvent\"\x000\x01B.Z,github.com/linkerd/linkerd2-proxy-api/go/tapb\x06proto3"

var (
	file_tap_proto_rawDescOnce sync.Once
	file_tap_proto_rawDescData []byte
)

func file_tap_proto_rawDescGZIP() []byte {
	file_tap_proto_rawDescOnce.Do(func() {
		file_tap_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_tap_proto_rawDesc), len(file_tap_proto_rawDesc)))
	})
	return file_tap_proto_rawDescData
}

var file_tap_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_tap_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
var file_tap_proto_goTypes = []any{
	(TapEvent_ProxyDirection)(0),                  // 0: io.linkerd.proxy.tap.TapEvent.ProxyDirection
	(*ObserveRequest)(nil),                        // 1: io.linkerd.proxy.tap.ObserveRequest
	(*Eos)(nil),                                   // 2: io.linkerd.proxy.tap.Eos
	(*TapEvent)(nil),                              // 3: io.linkerd.proxy.tap.TapEvent
	(*ObserveRequest_Match)(nil),                  // 4: io.linkerd.proxy.tap.ObserveRequest.Match
	(*ObserveRequest_Extract)(nil),                // 5: io.linkerd.proxy.tap.ObserveRequest.Extract
	(*ObserveRequest_Match_Seq)(nil),              // 6: io.linkerd.proxy.tap.ObserveRequest.Match.Seq
	(*ObserveRequest_Match_Label)(nil),            // 7: io.linkerd.proxy.tap.ObserveRequest.Match.Label
	(*ObserveRequest_Match_Tcp)(nil),              // 8: io.linkerd.proxy.tap.ObserveRequest.Match.Tcp
	(*ObserveRequest_Match_Http)(nil),             // 9: io.linkerd.proxy.tap.ObserveRequest.Match.Http
	(*ObserveRequest_Match_Tcp_Netmask)(nil),      // 10: io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.Netmask
	(*ObserveRequest_Match_Tcp_PortRange)(nil),    // 11: io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.PortRange
	(*ObserveRequest_Match_Http_StringMatch)(nil), // 12: io.linkerd.proxy.tap.ObserveRequest.Match.Http.StringMatch
	(*ObserveRequest_Extract_Http)(nil),           // 13: io.linkerd.proxy.tap.ObserveRequest.Extract.Http
	(*ObserveRequest_Extract_Http_Headers)(nil),   // 14: io.linkerd.proxy.tap.ObserveRequest.Extract.Http.Headers
	(*TapEvent_EndpointMeta)(nil),                 // 15: io.linkerd.proxy.tap.TapEvent.EndpointMeta
	(*TapEvent_RouteMeta)(nil),                    // 16: io.linkerd.proxy.tap.TapEvent.RouteMeta
	(*TapEvent_Http)(nil),                         // 17: io.linkerd.proxy.tap.TapEvent.Http
	nil,                                           // 18: io.linkerd.proxy.tap.TapEvent.EndpointMeta.LabelsEntry
	nil,                                           // 19: io.linkerd.proxy.tap.TapEvent.RouteMeta.LabelsEntry
	(*TapEvent_Http_StreamId)(nil),                // 20: io.linkerd.proxy.tap.TapEvent.Http.StreamId
	(*TapEvent_Http_RequestInit)(nil),             // 21: io.linkerd.proxy.tap.TapEvent.Http.RequestInit
	(*TapEvent_Http_ResponseInit)(nil),            // 22: io.linkerd.proxy.tap.TapEvent.Http.ResponseInit
	(*TapEvent_Http_ResponseEnd)(nil),             // 23: io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd
	(*net.TcpAddress)(nil),                        // 24: io.linkerd.proxy.net.TcpAddress
	(*http_types.Scheme)(nil),                     // 25: io.linkerd.proxy.http_types.Scheme
	(*http_types.HttpMethod)(nil),                 // 26: io.linkerd.proxy.http_types.HttpMethod
	(*net.IPAddress)(nil),                         // 27: io.linkerd.proxy.net.IPAddress
	(*http_types.Headers)(nil),                    // 28: io.linkerd.proxy.http_types.Headers
	(*duration.Duration)(nil),                     // 29: google.protobuf.Duration
}
var file_tap_proto_depIdxs = []int32{
	4,  // 0: io.linkerd.proxy.tap.ObserveRequest.match:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match
	5,  // 1: io.linkerd.proxy.tap.ObserveRequest.extract:type_name -> io.linkerd.proxy.tap.ObserveRequest.Extract
	24, // 2: io.linkerd.proxy.tap.TapEvent.source:type_name -> io.linkerd.proxy.net.TcpAddress
	15, // 3: io.linkerd.proxy.tap.TapEvent.source_meta:type_name -> io.linkerd.proxy.tap.TapEvent.EndpointMeta
	16, // 4: io.linkerd.proxy.tap.TapEvent.route_meta:type_name -> io.linkerd.proxy.tap.TapEvent.RouteMeta
	24, // 5: io.linkerd.proxy.tap.TapEvent.destination:type_name -> io.linkerd.proxy.net.TcpAddress
	15, // 6: io.linkerd.proxy.tap.TapEvent.destination_meta:type_name -> io.linkerd.proxy.tap.TapEvent.EndpointMeta
	0,  // 7: io.linkerd.proxy.tap.TapEvent.proxy_direction:type_name -> io.linkerd.proxy.tap.TapEvent.ProxyDirection
	17, // 8: io.linkerd.proxy.tap.TapEvent.http:type_name -> io.linkerd.proxy.tap.TapEvent.Http
	6,  // 9: io.linkerd.proxy.tap.ObserveRequest.Match.all:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Seq
	6,  // 10: io.linkerd.proxy.tap.ObserveRequest.Match.any:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Seq
	4,  // 11: io.linkerd.proxy.tap.ObserveRequest.Match.not:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match
	8,  // 12: io.linkerd.proxy.tap.ObserveRequest.Match.source:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Tcp
	8,  // 13: io.linkerd.proxy.tap.ObserveRequest.Match.destination:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Tcp
	9,  // 14: io.linkerd.proxy.tap.ObserveRequest.Match.http:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Http
	7,  // 15: io.linkerd.proxy.tap.ObserveRequest.Match.destination_label:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Label
	7,  // 16: io.linkerd.proxy.tap.ObserveRequest.Match.route_label:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Label
	13, // 17: io.linkerd.proxy.tap.ObserveRequest.Extract.http:type_name -> io.linkerd.proxy.tap.ObserveRequest.Extract.Http
	4,  // 18: io.linkerd.proxy.tap.ObserveRequest.Match.Seq.matches:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match
	10, // 19: io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.netmask:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.Netmask
	11, // 20: io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.ports:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.PortRange
	25, // 21: io.linkerd.proxy.tap.ObserveRequest.Match.Http.scheme:type_name -> io.linkerd.proxy.http_types.Scheme
	26, // 22: io.linkerd.proxy.tap.ObserveRequest.Match.Http.method:type_name -> io.linkerd.proxy.http_types.HttpMethod
	12, // 23: io.linkerd.proxy.tap.ObserveRequest.Match.Http.authority:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Http.StringMatch
	12, // 24: io.linkerd.proxy.tap.ObserveRequest.Match.Http.path:type_name -> io.linkerd.proxy.tap.ObserveRequest.Match.Http.StringMatch
	27, // 25: io.linkerd.proxy.tap.ObserveRequest.Match.Tcp.Netmask.ip:type_name -> io.linkerd.proxy.net.IPAddress
	14, // 26: io.linkerd.proxy.tap.ObserveRequest.Extract.Http.headers:type_name -> io.linkerd.proxy.tap.ObserveRequest.Extract.Http.Headers
	18, // 27: io.linkerd.proxy.tap.TapEvent.EndpointMeta.labels:type_name -> io.linkerd.proxy.tap.TapEvent.EndpointMeta.LabelsEntry
	19, // 28: io.linkerd.proxy.tap.TapEvent.RouteMeta.labels:type_name -> io.linkerd.proxy.tap.TapEvent.RouteMeta.LabelsEntry
	21, // 29: io.linkerd.proxy.tap.TapEvent.Http.request_init:type_name -> io.linkerd.proxy.tap.TapEvent.Http.RequestInit
	22, // 30: io.linkerd.proxy.tap.TapEvent.Http.response_init:type_name -> io.linkerd.proxy.tap.TapEvent.Http.ResponseInit
	23, // 31: io.linkerd.proxy.tap.TapEvent.Http.response_end:type_name -> io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd
	20, // 32: io.linkerd.proxy.tap.TapEvent.Http.RequestInit.id:type_name -> io.linkerd.proxy.tap.TapEvent.Http.StreamId
	26, // 33: io.linkerd.proxy.tap.TapEvent.Http.RequestInit.method:type_name -> io.linkerd.proxy.http_types.HttpMethod
	25, // 34: io.linkerd.proxy.tap.TapEvent.Http.RequestInit.scheme:type_name -> io.linkerd.proxy.http_types.Scheme
	28, // 35: io.linkerd.proxy.tap.TapEvent.Http.RequestInit.headers:type_name -> io.linkerd.proxy.http_types.Headers
	20, // 36: io.linkerd.proxy.tap.TapEvent.Http.ResponseInit.id:type_name -> io.linkerd.proxy.tap.TapEvent.Http.StreamId
	29, // 37: io.linkerd.proxy.tap.TapEvent.Http.ResponseInit.since_request_init:type_name -> google.protobuf.Duration
	28, // 38: io.linkerd.proxy.tap.TapEvent.Http.ResponseInit.headers:type_name -> io.linkerd.proxy.http_types.Headers
	20, // 39: io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd.id:type_name -> io.linkerd.proxy.tap.TapEvent.Http.StreamId
	29, // 40: io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd.since_request_init:type_name -> google.protobuf.Duration
	29, // 41: io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd.since_response_init:type_name -> google.protobuf.Duration
	2,  // 42: io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd.eos:type_name -> io.linkerd.proxy.tap.Eos
	28, // 43: io.linkerd.proxy.tap.TapEvent.Http.ResponseEnd.trailers:type_name -> io.linkerd.proxy.http_types.Headers
	1,  // 44: io.linkerd.proxy.tap.Tap.Observe:input_type -> io.linkerd.proxy.tap.ObserveRequest
	3,  // 45: io.linkerd.proxy.tap.Tap.Observe:output_type -> io.linkerd.proxy.tap.TapEvent
	45, // [45:46] is the sub-list for method output_type
	44, // [44:45] is the sub-list for method input_type
	44, // [44:44] is the sub-list for extension type_name
	44, // [44:44] is the sub-list for extension extendee
	0,  // [0:44] is the sub-list for field type_name
}

func init() { file_tap_proto_init() }
func file_tap_proto_init() {
	if File_tap_proto != nil {
		return
	}
	file_tap_proto_msgTypes[1].OneofWrappers = []any{
		(*Eos_GrpcStatusCode)(nil),
		(*Eos_ResetErrorCode)(nil),
	}
	file_tap_proto_msgTypes[2].OneofWrappers = []any{
		(*TapEvent_Http_)(nil),
	}
	file_tap_proto_msgTypes[3].OneofWrappers = []any{
		(*ObserveRequest_Match_All)(nil),
		(*ObserveRequest_Match_Any)(nil),
		(*ObserveRequest_Match_Not)(nil),
		(*ObserveRequest_Match_Source)(nil),
		(*ObserveRequest_Match_Destination)(nil),
		(*ObserveRequest_Match_Http_)(nil),
		(*ObserveRequest_Match_DestinationLabel)(nil),
		(*ObserveRequest_Match_RouteLabel)(nil),
	}
	file_tap_proto_msgTypes[4].OneofWrappers = []any{
		(*ObserveRequest_Extract_Http_)(nil),
	}
	file_tap_proto_msgTypes[7].OneofWrappers = []any{
		(*ObserveRequest_Match_Tcp_Netmask_)(nil),
		(*ObserveRequest_Match_Tcp_Ports)(nil),
	}
	file_tap_proto_msgTypes[8].OneofWrappers = []any{
		(*ObserveRequest_Match_Http_Scheme)(nil),
		(*ObserveRequest_Match_Http_Method)(nil),
		(*ObserveRequest_Match_Http_Authority)(nil),
		(*ObserveRequest_Match_Http_Path)(nil),
	}
	file_tap_proto_msgTypes[11].OneofWrappers = []any{
		(*ObserveRequest_Match_Http_StringMatch_Exact)(nil),
		(*ObserveRequest_Match_Http_StringMatch_Prefix)(nil),
	}
	file_tap_proto_msgTypes[12].OneofWrappers = []any{
		(*ObserveRequest_Extract_Http_Headers_)(nil),
	}
	file_tap_proto_msgTypes[16].OneofWrappers = []any{
		(*TapEvent_Http_RequestInit_)(nil),
		(*TapEvent_Http_ResponseInit_)(nil),
		(*TapEvent_Http_ResponseEnd_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_tap_proto_rawDesc), len(file_tap_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_tap_proto_goTypes,
		DependencyIndexes: file_tap_proto_depIdxs,
		EnumInfos:         file_tap_proto_enumTypes,
		MessageInfos:      file_tap_proto_msgTypes,
	}.Build()
	File_tap_proto = out.File
	file_tap_proto_goTypes = nil
	file_tap_proto_depIdxs = nil
}