public.pb.go

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

package public // import "github.com/linkerd/linkerd2/controller/gen/public"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import duration "github.com/golang/protobuf/ptypes/duration"
import healthcheck "github.com/linkerd/linkerd2/controller/gen/common/healthcheck"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type HttpMethod_Registered int32

const (
	HttpMethod_GET     HttpMethod_Registered = 0
	HttpMethod_POST    HttpMethod_Registered = 1
	HttpMethod_PUT     HttpMethod_Registered = 2
	HttpMethod_DELETE  HttpMethod_Registered = 3
	HttpMethod_PATCH   HttpMethod_Registered = 4
	HttpMethod_OPTIONS HttpMethod_Registered = 5
	HttpMethod_CONNECT HttpMethod_Registered = 6
	HttpMethod_HEAD    HttpMethod_Registered = 7
	HttpMethod_TRACE   HttpMethod_Registered = 8
)

var HttpMethod_Registered_name = map[int32]string{
	0: "GET",
	1: "POST",
	2: "PUT",
	3: "DELETE",
	4: "PATCH",
	5: "OPTIONS",
	6: "CONNECT",
	7: "HEAD",
	8: "TRACE",
}
var HttpMethod_Registered_value = map[string]int32{
	"GET":     0,
	"POST":    1,
	"PUT":     2,
	"DELETE":  3,
	"PATCH":   4,
	"OPTIONS": 5,
	"CONNECT": 6,
	"HEAD":    7,
	"TRACE":   8,
}

func (x HttpMethod_Registered) String() string {
	return proto.EnumName(HttpMethod_Registered_name, int32(x))
}
func (HttpMethod_Registered) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{7, 0}
}

type Scheme_Registered int32

const (
	Scheme_HTTP  Scheme_Registered = 0
	Scheme_HTTPS Scheme_Registered = 1
)

var Scheme_Registered_name = map[int32]string{
	0: "HTTP",
	1: "HTTPS",
}
var Scheme_Registered_value = map[string]int32{
	"HTTP":  0,
	"HTTPS": 1,
}

func (x Scheme_Registered) String() string {
	return proto.EnumName(Scheme_Registered_name, int32(x))
}
func (Scheme_Registered) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{8, 0}
}

type TapEvent_ProxyDirection int32

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

var TapEvent_ProxyDirection_name = map[int32]string{
	0: "UNKNOWN",
	1: "INBOUND",
	2: "OUTBOUND",
}
var TapEvent_ProxyDirection_value = map[string]int32{
	"UNKNOWN":  0,
	"INBOUND":  1,
	"OUTBOUND": 2,
}

func (x TapEvent_ProxyDirection) String() string {
	return proto.EnumName(TapEvent_ProxyDirection_name, int32(x))
}
func (TapEvent_ProxyDirection) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 0}
}

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

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{0}
}
func (m *Empty) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (dst *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(dst, src)
}
func (m *Empty) XXX_Size() int {
	return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type VersionInfo struct {
	GoVersion            string   `protobuf:"bytes,1,opt,name=goVersion,proto3" json:"goVersion,omitempty"`
	BuildDate            string   `protobuf:"bytes,2,opt,name=buildDate,proto3" json:"buildDate,omitempty"`
	ReleaseVersion       string   `protobuf:"bytes,3,opt,name=releaseVersion,proto3" json:"releaseVersion,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VersionInfo) Reset()         { *m = VersionInfo{} }
func (m *VersionInfo) String() string { return proto.CompactTextString(m) }
func (*VersionInfo) ProtoMessage()    {}
func (*VersionInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{1}
}
func (m *VersionInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VersionInfo.Unmarshal(m, b)
}
func (m *VersionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VersionInfo.Marshal(b, m, deterministic)
}
func (dst *VersionInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VersionInfo.Merge(dst, src)
}
func (m *VersionInfo) XXX_Size() int {
	return xxx_messageInfo_VersionInfo.Size(m)
}
func (m *VersionInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_VersionInfo.DiscardUnknown(m)
}

var xxx_messageInfo_VersionInfo proto.InternalMessageInfo

func (m *VersionInfo) GetGoVersion() string {
	if m != nil {
		return m.GoVersion
	}
	return ""
}

func (m *VersionInfo) GetBuildDate() string {
	if m != nil {
		return m.BuildDate
	}
	return ""
}

func (m *VersionInfo) GetReleaseVersion() string {
	if m != nil {
		return m.ReleaseVersion
	}
	return ""
}

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

func (m *ListPodsRequest) Reset()         { *m = ListPodsRequest{} }
func (m *ListPodsRequest) String() string { return proto.CompactTextString(m) }
func (*ListPodsRequest) ProtoMessage()    {}
func (*ListPodsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{2}
}
func (m *ListPodsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListPodsRequest.Unmarshal(m, b)
}
func (m *ListPodsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListPodsRequest.Marshal(b, m, deterministic)
}
func (dst *ListPodsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListPodsRequest.Merge(dst, src)
}
func (m *ListPodsRequest) XXX_Size() int {
	return xxx_messageInfo_ListPodsRequest.Size(m)
}
func (m *ListPodsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListPodsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListPodsRequest proto.InternalMessageInfo

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

type ListPodsResponse struct {
	Pods                 []*Pod   `protobuf:"bytes,1,rep,name=pods,proto3" json:"pods,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListPodsResponse) Reset()         { *m = ListPodsResponse{} }
func (m *ListPodsResponse) String() string { return proto.CompactTextString(m) }
func (*ListPodsResponse) ProtoMessage()    {}
func (*ListPodsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{3}
}
func (m *ListPodsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListPodsResponse.Unmarshal(m, b)
}
func (m *ListPodsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListPodsResponse.Marshal(b, m, deterministic)
}
func (dst *ListPodsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListPodsResponse.Merge(dst, src)
}
func (m *ListPodsResponse) XXX_Size() int {
	return xxx_messageInfo_ListPodsResponse.Size(m)
}
func (m *ListPodsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListPodsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListPodsResponse proto.InternalMessageInfo

func (m *ListPodsResponse) GetPods() []*Pod {
	if m != nil {
		return m.Pods
	}
	return nil
}

type Pod struct {
	Name  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	PodIP string `protobuf:"bytes,2,opt,name=podIP,proto3" json:"podIP,omitempty"`
	// Types that are valid to be assigned to Owner:
	//	*Pod_Deployment
	//	*Pod_ReplicaSet
	//	*Pod_ReplicationController
	//	*Pod_StatefulSet
	//	*Pod_DaemonSet
	//	*Pod_Job
	Owner                isPod_Owner        `protobuf_oneof:"owner"`
	Status               string             `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	Added                bool               `protobuf:"varint,5,opt,name=added,proto3" json:"added,omitempty"`
	SinceLastReport      *duration.Duration `protobuf:"bytes,6,opt,name=sinceLastReport,proto3" json:"sinceLastReport,omitempty"`
	ControllerNamespace  string             `protobuf:"bytes,7,opt,name=controllerNamespace,proto3" json:"controllerNamespace,omitempty"`
	ControlPlane         bool               `protobuf:"varint,8,opt,name=controlPlane,proto3" json:"controlPlane,omitempty"`
	Uptime               *duration.Duration `protobuf:"bytes,9,opt,name=uptime,proto3" json:"uptime,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Pod) Reset()         { *m = Pod{} }
func (m *Pod) String() string { return proto.CompactTextString(m) }
func (*Pod) ProtoMessage()    {}
func (*Pod) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{4}
}
func (m *Pod) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Pod.Unmarshal(m, b)
}
func (m *Pod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Pod.Marshal(b, m, deterministic)
}
func (dst *Pod) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pod.Merge(dst, src)
}
func (m *Pod) XXX_Size() int {
	return xxx_messageInfo_Pod.Size(m)
}
func (m *Pod) XXX_DiscardUnknown() {
	xxx_messageInfo_Pod.DiscardUnknown(m)
}

var xxx_messageInfo_Pod proto.InternalMessageInfo

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

func (m *Pod) GetPodIP() string {
	if m != nil {
		return m.PodIP
	}
	return ""
}

type isPod_Owner interface {
	isPod_Owner()
}

type Pod_Deployment struct {
	Deployment string `protobuf:"bytes,3,opt,name=deployment,proto3,oneof"`
}

type Pod_ReplicaSet struct {
	ReplicaSet string `protobuf:"bytes,10,opt,name=replica_set,json=replicaSet,proto3,oneof"`
}

type Pod_ReplicationController struct {
	ReplicationController string `protobuf:"bytes,11,opt,name=replication_controller,json=replicationController,proto3,oneof"`
}

type Pod_StatefulSet struct {
	StatefulSet string `protobuf:"bytes,12,opt,name=stateful_set,json=statefulSet,proto3,oneof"`
}

type Pod_DaemonSet struct {
	DaemonSet string `protobuf:"bytes,13,opt,name=daemon_set,json=daemonSet,proto3,oneof"`
}

type Pod_Job struct {
	Job string `protobuf:"bytes,14,opt,name=job,proto3,oneof"`
}

func (*Pod_Deployment) isPod_Owner() {}

func (*Pod_ReplicaSet) isPod_Owner() {}

func (*Pod_ReplicationController) isPod_Owner() {}

func (*Pod_StatefulSet) isPod_Owner() {}

func (*Pod_DaemonSet) isPod_Owner() {}

func (*Pod_Job) isPod_Owner() {}

func (m *Pod) GetOwner() isPod_Owner {
	if m != nil {
		return m.Owner
	}
	return nil
}

func (m *Pod) GetDeployment() string {
	if x, ok := m.GetOwner().(*Pod_Deployment); ok {
		return x.Deployment
	}
	return ""
}

func (m *Pod) GetReplicaSet() string {
	if x, ok := m.GetOwner().(*Pod_ReplicaSet); ok {
		return x.ReplicaSet
	}
	return ""
}

func (m *Pod) GetReplicationController() string {
	if x, ok := m.GetOwner().(*Pod_ReplicationController); ok {
		return x.ReplicationController
	}
	return ""
}

func (m *Pod) GetStatefulSet() string {
	if x, ok := m.GetOwner().(*Pod_StatefulSet); ok {
		return x.StatefulSet
	}
	return ""
}

func (m *Pod) GetDaemonSet() string {
	if x, ok := m.GetOwner().(*Pod_DaemonSet); ok {
		return x.DaemonSet
	}
	return ""
}

func (m *Pod) GetJob() string {
	if x, ok := m.GetOwner().(*Pod_Job); ok {
		return x.Job
	}
	return ""
}

func (m *Pod) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *Pod) GetAdded() bool {
	if m != nil {
		return m.Added
	}
	return false
}

func (m *Pod) GetSinceLastReport() *duration.Duration {
	if m != nil {
		return m.SinceLastReport
	}
	return nil
}

func (m *Pod) GetControllerNamespace() string {
	if m != nil {
		return m.ControllerNamespace
	}
	return ""
}

func (m *Pod) GetControlPlane() bool {
	if m != nil {
		return m.ControlPlane
	}
	return false
}

func (m *Pod) GetUptime() *duration.Duration {
	if m != nil {
		return m.Uptime
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Pod) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Pod_OneofMarshaler, _Pod_OneofUnmarshaler, _Pod_OneofSizer, []interface{}{
		(*Pod_Deployment)(nil),
		(*Pod_ReplicaSet)(nil),
		(*Pod_ReplicationController)(nil),
		(*Pod_StatefulSet)(nil),
		(*Pod_DaemonSet)(nil),
		(*Pod_Job)(nil),
	}
}

func _Pod_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Pod)
	// owner
	switch x := m.Owner.(type) {
	case *Pod_Deployment:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Deployment)
	case *Pod_ReplicaSet:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.ReplicaSet)
	case *Pod_ReplicationController:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.ReplicationController)
	case *Pod_StatefulSet:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.StatefulSet)
	case *Pod_DaemonSet:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.DaemonSet)
	case *Pod_Job:
		b.EncodeVarint(14<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Job)
	case nil:
	default:
		return fmt.Errorf("Pod.Owner has unexpected type %T", x)
	}
	return nil
}

func _Pod_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Pod)
	switch tag {
	case 3: // owner.deployment
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Owner = &Pod_Deployment{x}
		return true, err
	case 10: // owner.replica_set
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Owner = &Pod_ReplicaSet{x}
		return true, err
	case 11: // owner.replication_controller
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Owner = &Pod_ReplicationController{x}
		return true, err
	case 12: // owner.stateful_set
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Owner = &Pod_StatefulSet{x}
		return true, err
	case 13: // owner.daemon_set
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Owner = &Pod_DaemonSet{x}
		return true, err
	case 14: // owner.job
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Owner = &Pod_Job{x}
		return true, err
	default:
		return false, nil
	}
}

func _Pod_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Pod)
	// owner
	switch x := m.Owner.(type) {
	case *Pod_Deployment:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Deployment)))
		n += len(x.Deployment)
	case *Pod_ReplicaSet:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.ReplicaSet)))
		n += len(x.ReplicaSet)
	case *Pod_ReplicationController:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.ReplicationController)))
		n += len(x.ReplicationController)
	case *Pod_StatefulSet:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.StatefulSet)))
		n += len(x.StatefulSet)
	case *Pod_DaemonSet:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.DaemonSet)))
		n += len(x.DaemonSet)
	case *Pod_Job:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Job)))
		n += len(x.Job)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Deprecated: Do not use.
type TapRequest struct {
	// Types that are valid to be assigned to Target:
	//	*TapRequest_Pod
	//	*TapRequest_Deployment
	Target isTapRequest_Target `protobuf_oneof:"target"`
	// validation of these fields happens on the server
	MaxRps               float32  `protobuf:"fixed32,3,opt,name=maxRps,proto3" json:"maxRps,omitempty"`
	ToPort               uint32   `protobuf:"varint,4,opt,name=toPort,proto3" json:"toPort,omitempty"`
	ToIP                 string   `protobuf:"bytes,5,opt,name=toIP,proto3" json:"toIP,omitempty"`
	FromPort             uint32   `protobuf:"varint,6,opt,name=fromPort,proto3" json:"fromPort,omitempty"`
	FromIP               string   `protobuf:"bytes,7,opt,name=fromIP,proto3" json:"fromIP,omitempty"`
	Scheme               string   `protobuf:"bytes,8,opt,name=scheme,proto3" json:"scheme,omitempty"`
	Method               string   `protobuf:"bytes,9,opt,name=method,proto3" json:"method,omitempty"`
	Authority            string   `protobuf:"bytes,10,opt,name=authority,proto3" json:"authority,omitempty"`
	Path                 string   `protobuf:"bytes,11,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TapRequest) Reset()         { *m = TapRequest{} }
func (m *TapRequest) String() string { return proto.CompactTextString(m) }
func (*TapRequest) ProtoMessage()    {}
func (*TapRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{5}
}
func (m *TapRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapRequest.Unmarshal(m, b)
}
func (m *TapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapRequest.Marshal(b, m, deterministic)
}
func (dst *TapRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapRequest.Merge(dst, src)
}
func (m *TapRequest) XXX_Size() int {
	return xxx_messageInfo_TapRequest.Size(m)
}
func (m *TapRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TapRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TapRequest proto.InternalMessageInfo

type isTapRequest_Target interface {
	isTapRequest_Target()
}

type TapRequest_Pod struct {
	Pod string `protobuf:"bytes,1,opt,name=pod,proto3,oneof"`
}

type TapRequest_Deployment struct {
	Deployment string `protobuf:"bytes,2,opt,name=deployment,proto3,oneof"`
}

func (*TapRequest_Pod) isTapRequest_Target() {}

func (*TapRequest_Deployment) isTapRequest_Target() {}

func (m *TapRequest) GetTarget() isTapRequest_Target {
	if m != nil {
		return m.Target
	}
	return nil
}

func (m *TapRequest) GetPod() string {
	if x, ok := m.GetTarget().(*TapRequest_Pod); ok {
		return x.Pod
	}
	return ""
}

func (m *TapRequest) GetDeployment() string {
	if x, ok := m.GetTarget().(*TapRequest_Deployment); ok {
		return x.Deployment
	}
	return ""
}

func (m *TapRequest) GetMaxRps() float32 {
	if m != nil {
		return m.MaxRps
	}
	return 0
}

func (m *TapRequest) GetToPort() uint32 {
	if m != nil {
		return m.ToPort
	}
	return 0
}

func (m *TapRequest) GetToIP() string {
	if m != nil {
		return m.ToIP
	}
	return ""
}

func (m *TapRequest) GetFromPort() uint32 {
	if m != nil {
		return m.FromPort
	}
	return 0
}

func (m *TapRequest) GetFromIP() string {
	if m != nil {
		return m.FromIP
	}
	return ""
}

func (m *TapRequest) GetScheme() string {
	if m != nil {
		return m.Scheme
	}
	return ""
}

func (m *TapRequest) GetMethod() string {
	if m != nil {
		return m.Method
	}
	return ""
}

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TapRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TapRequest_OneofMarshaler, _TapRequest_OneofUnmarshaler, _TapRequest_OneofSizer, []interface{}{
		(*TapRequest_Pod)(nil),
		(*TapRequest_Deployment)(nil),
	}
}

func _TapRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TapRequest)
	// target
	switch x := m.Target.(type) {
	case *TapRequest_Pod:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Pod)
	case *TapRequest_Deployment:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Deployment)
	case nil:
	default:
		return fmt.Errorf("TapRequest.Target has unexpected type %T", x)
	}
	return nil
}

func _TapRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TapRequest)
	switch tag {
	case 1: // target.pod
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Target = &TapRequest_Pod{x}
		return true, err
	case 2: // target.deployment
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Target = &TapRequest_Deployment{x}
		return true, err
	default:
		return false, nil
	}
}

func _TapRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TapRequest)
	// target
	switch x := m.Target.(type) {
	case *TapRequest_Pod:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Pod)))
		n += len(x.Pod)
	case *TapRequest_Deployment:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Deployment)))
		n += len(x.Deployment)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A tap request over kubernetes resources.
type TapByResourceRequest struct {
	// Describes the kubernetes pods that should be tapped.
	Target *ResourceSelection `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// Selects over events to be reported.
	Match *TapByResourceRequest_Match `protobuf:"bytes,2,opt,name=match,proto3" json:"match,omitempty"`
	// Limits the number of events to be inspected.
	MaxRps               float32  `protobuf:"fixed32,3,opt,name=maxRps,proto3" json:"maxRps,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TapByResourceRequest) Reset()         { *m = TapByResourceRequest{} }
func (m *TapByResourceRequest) String() string { return proto.CompactTextString(m) }
func (*TapByResourceRequest) ProtoMessage()    {}
func (*TapByResourceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{6}
}
func (m *TapByResourceRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapByResourceRequest.Unmarshal(m, b)
}
func (m *TapByResourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapByResourceRequest.Marshal(b, m, deterministic)
}
func (dst *TapByResourceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapByResourceRequest.Merge(dst, src)
}
func (m *TapByResourceRequest) XXX_Size() int {
	return xxx_messageInfo_TapByResourceRequest.Size(m)
}
func (m *TapByResourceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TapByResourceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TapByResourceRequest proto.InternalMessageInfo

func (m *TapByResourceRequest) GetTarget() *ResourceSelection {
	if m != nil {
		return m.Target
	}
	return nil
}

func (m *TapByResourceRequest) GetMatch() *TapByResourceRequest_Match {
	if m != nil {
		return m.Match
	}
	return nil
}

func (m *TapByResourceRequest) GetMaxRps() float32 {
	if m != nil {
		return m.MaxRps
	}
	return 0
}

type TapByResourceRequest_Match struct {
	// Types that are valid to be assigned to Match:
	//	*TapByResourceRequest_Match_All
	//	*TapByResourceRequest_Match_Any
	//	*TapByResourceRequest_Match_Not
	//	*TapByResourceRequest_Match_Destinations
	//	*TapByResourceRequest_Match_Http_
	Match                isTapByResourceRequest_Match_Match `protobuf_oneof:"match"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

func (m *TapByResourceRequest_Match) Reset()         { *m = TapByResourceRequest_Match{} }
func (m *TapByResourceRequest_Match) String() string { return proto.CompactTextString(m) }
func (*TapByResourceRequest_Match) ProtoMessage()    {}
func (*TapByResourceRequest_Match) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{6, 0}
}
func (m *TapByResourceRequest_Match) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapByResourceRequest_Match.Unmarshal(m, b)
}
func (m *TapByResourceRequest_Match) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapByResourceRequest_Match.Marshal(b, m, deterministic)
}
func (dst *TapByResourceRequest_Match) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapByResourceRequest_Match.Merge(dst, src)
}
func (m *TapByResourceRequest_Match) XXX_Size() int {
	return xxx_messageInfo_TapByResourceRequest_Match.Size(m)
}
func (m *TapByResourceRequest_Match) XXX_DiscardUnknown() {
	xxx_messageInfo_TapByResourceRequest_Match.DiscardUnknown(m)
}

var xxx_messageInfo_TapByResourceRequest_Match proto.InternalMessageInfo

type isTapByResourceRequest_Match_Match interface {
	isTapByResourceRequest_Match_Match()
}

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

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

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

type TapByResourceRequest_Match_Destinations struct {
	Destinations *ResourceSelection `protobuf:"bytes,4,opt,name=destinations,proto3,oneof"`
}

type TapByResourceRequest_Match_Http_ struct {
	Http *TapByResourceRequest_Match_Http `protobuf:"bytes,5,opt,name=http,proto3,oneof"`
}

func (*TapByResourceRequest_Match_All) isTapByResourceRequest_Match_Match() {}

func (*TapByResourceRequest_Match_Any) isTapByResourceRequest_Match_Match() {}

func (*TapByResourceRequest_Match_Not) isTapByResourceRequest_Match_Match() {}

func (*TapByResourceRequest_Match_Destinations) isTapByResourceRequest_Match_Match() {}

func (*TapByResourceRequest_Match_Http_) isTapByResourceRequest_Match_Match() {}

func (m *TapByResourceRequest_Match) GetMatch() isTapByResourceRequest_Match_Match {
	if m != nil {
		return m.Match
	}
	return nil
}

func (m *TapByResourceRequest_Match) GetAll() *TapByResourceRequest_Match_Seq {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_All); ok {
		return x.All
	}
	return nil
}

func (m *TapByResourceRequest_Match) GetAny() *TapByResourceRequest_Match_Seq {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Any); ok {
		return x.Any
	}
	return nil
}

func (m *TapByResourceRequest_Match) GetNot() *TapByResourceRequest_Match {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Not); ok {
		return x.Not
	}
	return nil
}

func (m *TapByResourceRequest_Match) GetDestinations() *ResourceSelection {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Destinations); ok {
		return x.Destinations
	}
	return nil
}

func (m *TapByResourceRequest_Match) GetHttp() *TapByResourceRequest_Match_Http {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Http_); ok {
		return x.Http
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TapByResourceRequest_Match) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TapByResourceRequest_Match_OneofMarshaler, _TapByResourceRequest_Match_OneofUnmarshaler, _TapByResourceRequest_Match_OneofSizer, []interface{}{
		(*TapByResourceRequest_Match_All)(nil),
		(*TapByResourceRequest_Match_Any)(nil),
		(*TapByResourceRequest_Match_Not)(nil),
		(*TapByResourceRequest_Match_Destinations)(nil),
		(*TapByResourceRequest_Match_Http_)(nil),
	}
}

func _TapByResourceRequest_Match_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TapByResourceRequest_Match)
	// match
	switch x := m.Match.(type) {
	case *TapByResourceRequest_Match_All:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.All); err != nil {
			return err
		}
	case *TapByResourceRequest_Match_Any:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Any); err != nil {
			return err
		}
	case *TapByResourceRequest_Match_Not:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Not); err != nil {
			return err
		}
	case *TapByResourceRequest_Match_Destinations:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Destinations); err != nil {
			return err
		}
	case *TapByResourceRequest_Match_Http_:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Http); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TapByResourceRequest_Match.Match has unexpected type %T", x)
	}
	return nil
}

func _TapByResourceRequest_Match_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TapByResourceRequest_Match)
	switch tag {
	case 1: // match.all
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapByResourceRequest_Match_Seq)
		err := b.DecodeMessage(msg)
		m.Match = &TapByResourceRequest_Match_All{msg}
		return true, err
	case 2: // match.any
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapByResourceRequest_Match_Seq)
		err := b.DecodeMessage(msg)
		m.Match = &TapByResourceRequest_Match_Any{msg}
		return true, err
	case 3: // match.not
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapByResourceRequest_Match)
		err := b.DecodeMessage(msg)
		m.Match = &TapByResourceRequest_Match_Not{msg}
		return true, err
	case 4: // match.destinations
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResourceSelection)
		err := b.DecodeMessage(msg)
		m.Match = &TapByResourceRequest_Match_Destinations{msg}
		return true, err
	case 5: // match.http
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapByResourceRequest_Match_Http)
		err := b.DecodeMessage(msg)
		m.Match = &TapByResourceRequest_Match_Http_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TapByResourceRequest_Match_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TapByResourceRequest_Match)
	// match
	switch x := m.Match.(type) {
	case *TapByResourceRequest_Match_All:
		s := proto.Size(x.All)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TapByResourceRequest_Match_Any:
		s := proto.Size(x.Any)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TapByResourceRequest_Match_Not:
		s := proto.Size(x.Not)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TapByResourceRequest_Match_Destinations:
		s := proto.Size(x.Destinations)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TapByResourceRequest_Match_Http_:
		s := proto.Size(x.Http)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TapByResourceRequest_Match_Seq struct {
	Matches              []*TapByResourceRequest_Match `protobuf:"bytes,1,rep,name=matches,proto3" json:"matches,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *TapByResourceRequest_Match_Seq) Reset()         { *m = TapByResourceRequest_Match_Seq{} }
func (m *TapByResourceRequest_Match_Seq) String() string { return proto.CompactTextString(m) }
func (*TapByResourceRequest_Match_Seq) ProtoMessage()    {}
func (*TapByResourceRequest_Match_Seq) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{6, 0, 0}
}
func (m *TapByResourceRequest_Match_Seq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapByResourceRequest_Match_Seq.Unmarshal(m, b)
}
func (m *TapByResourceRequest_Match_Seq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapByResourceRequest_Match_Seq.Marshal(b, m, deterministic)
}
func (dst *TapByResourceRequest_Match_Seq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapByResourceRequest_Match_Seq.Merge(dst, src)
}
func (m *TapByResourceRequest_Match_Seq) XXX_Size() int {
	return xxx_messageInfo_TapByResourceRequest_Match_Seq.Size(m)
}
func (m *TapByResourceRequest_Match_Seq) XXX_DiscardUnknown() {
	xxx_messageInfo_TapByResourceRequest_Match_Seq.DiscardUnknown(m)
}

var xxx_messageInfo_TapByResourceRequest_Match_Seq proto.InternalMessageInfo

func (m *TapByResourceRequest_Match_Seq) GetMatches() []*TapByResourceRequest_Match {
	if m != nil {
		return m.Matches
	}
	return nil
}

type TapByResourceRequest_Match_Http struct {
	// Types that are valid to be assigned to Match:
	//	*TapByResourceRequest_Match_Http_Scheme
	//	*TapByResourceRequest_Match_Http_Method
	//	*TapByResourceRequest_Match_Http_Authority
	//	*TapByResourceRequest_Match_Http_Path
	Match                isTapByResourceRequest_Match_Http_Match `protobuf_oneof:"match"`
	XXX_NoUnkeyedLiteral struct{}                                `json:"-"`
	XXX_unrecognized     []byte                                  `json:"-"`
	XXX_sizecache        int32                                   `json:"-"`
}

func (m *TapByResourceRequest_Match_Http) Reset()         { *m = TapByResourceRequest_Match_Http{} }
func (m *TapByResourceRequest_Match_Http) String() string { return proto.CompactTextString(m) }
func (*TapByResourceRequest_Match_Http) ProtoMessage()    {}
func (*TapByResourceRequest_Match_Http) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{6, 0, 1}
}
func (m *TapByResourceRequest_Match_Http) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapByResourceRequest_Match_Http.Unmarshal(m, b)
}
func (m *TapByResourceRequest_Match_Http) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapByResourceRequest_Match_Http.Marshal(b, m, deterministic)
}
func (dst *TapByResourceRequest_Match_Http) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapByResourceRequest_Match_Http.Merge(dst, src)
}
func (m *TapByResourceRequest_Match_Http) XXX_Size() int {
	return xxx_messageInfo_TapByResourceRequest_Match_Http.Size(m)
}
func (m *TapByResourceRequest_Match_Http) XXX_DiscardUnknown() {
	xxx_messageInfo_TapByResourceRequest_Match_Http.DiscardUnknown(m)
}

var xxx_messageInfo_TapByResourceRequest_Match_Http proto.InternalMessageInfo

type isTapByResourceRequest_Match_Http_Match interface {
	isTapByResourceRequest_Match_Http_Match()
}

type TapByResourceRequest_Match_Http_Scheme struct {
	Scheme string `protobuf:"bytes,1,opt,name=scheme,proto3,oneof"`
}

type TapByResourceRequest_Match_Http_Method struct {
	Method string `protobuf:"bytes,2,opt,name=method,proto3,oneof"`
}

type TapByResourceRequest_Match_Http_Authority struct {
	Authority string `protobuf:"bytes,3,opt,name=authority,proto3,oneof"`
}

type TapByResourceRequest_Match_Http_Path struct {
	Path string `protobuf:"bytes,4,opt,name=path,proto3,oneof"`
}

func (*TapByResourceRequest_Match_Http_Scheme) isTapByResourceRequest_Match_Http_Match() {}

func (*TapByResourceRequest_Match_Http_Method) isTapByResourceRequest_Match_Http_Match() {}

func (*TapByResourceRequest_Match_Http_Authority) isTapByResourceRequest_Match_Http_Match() {}

func (*TapByResourceRequest_Match_Http_Path) isTapByResourceRequest_Match_Http_Match() {}

func (m *TapByResourceRequest_Match_Http) GetMatch() isTapByResourceRequest_Match_Http_Match {
	if m != nil {
		return m.Match
	}
	return nil
}

func (m *TapByResourceRequest_Match_Http) GetScheme() string {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Http_Scheme); ok {
		return x.Scheme
	}
	return ""
}

func (m *TapByResourceRequest_Match_Http) GetMethod() string {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Http_Method); ok {
		return x.Method
	}
	return ""
}

func (m *TapByResourceRequest_Match_Http) GetAuthority() string {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Http_Authority); ok {
		return x.Authority
	}
	return ""
}

func (m *TapByResourceRequest_Match_Http) GetPath() string {
	if x, ok := m.GetMatch().(*TapByResourceRequest_Match_Http_Path); ok {
		return x.Path
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TapByResourceRequest_Match_Http) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TapByResourceRequest_Match_Http_OneofMarshaler, _TapByResourceRequest_Match_Http_OneofUnmarshaler, _TapByResourceRequest_Match_Http_OneofSizer, []interface{}{
		(*TapByResourceRequest_Match_Http_Scheme)(nil),
		(*TapByResourceRequest_Match_Http_Method)(nil),
		(*TapByResourceRequest_Match_Http_Authority)(nil),
		(*TapByResourceRequest_Match_Http_Path)(nil),
	}
}

func _TapByResourceRequest_Match_Http_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TapByResourceRequest_Match_Http)
	// match
	switch x := m.Match.(type) {
	case *TapByResourceRequest_Match_Http_Scheme:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Scheme)
	case *TapByResourceRequest_Match_Http_Method:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Method)
	case *TapByResourceRequest_Match_Http_Authority:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Authority)
	case *TapByResourceRequest_Match_Http_Path:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Path)
	case nil:
	default:
		return fmt.Errorf("TapByResourceRequest_Match_Http.Match has unexpected type %T", x)
	}
	return nil
}

func _TapByResourceRequest_Match_Http_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TapByResourceRequest_Match_Http)
	switch tag {
	case 1: // match.scheme
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Match = &TapByResourceRequest_Match_Http_Scheme{x}
		return true, err
	case 2: // match.method
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Match = &TapByResourceRequest_Match_Http_Method{x}
		return true, err
	case 3: // match.authority
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Match = &TapByResourceRequest_Match_Http_Authority{x}
		return true, err
	case 4: // match.path
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Match = &TapByResourceRequest_Match_Http_Path{x}
		return true, err
	default:
		return false, nil
	}
}

func _TapByResourceRequest_Match_Http_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TapByResourceRequest_Match_Http)
	// match
	switch x := m.Match.(type) {
	case *TapByResourceRequest_Match_Http_Scheme:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Scheme)))
		n += len(x.Scheme)
	case *TapByResourceRequest_Match_Http_Method:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Method)))
		n += len(x.Method)
	case *TapByResourceRequest_Match_Http_Authority:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Authority)))
		n += len(x.Authority)
	case *TapByResourceRequest_Match_Http_Path:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Path)))
		n += len(x.Path)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type HttpMethod struct {
	// Types that are valid to be assigned to Type:
	//	*HttpMethod_Registered_
	//	*HttpMethod_Unregistered
	Type                 isHttpMethod_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *HttpMethod) Reset()         { *m = HttpMethod{} }
func (m *HttpMethod) String() string { return proto.CompactTextString(m) }
func (*HttpMethod) ProtoMessage()    {}
func (*HttpMethod) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{7}
}
func (m *HttpMethod) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HttpMethod.Unmarshal(m, b)
}
func (m *HttpMethod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HttpMethod.Marshal(b, m, deterministic)
}
func (dst *HttpMethod) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HttpMethod.Merge(dst, src)
}
func (m *HttpMethod) XXX_Size() int {
	return xxx_messageInfo_HttpMethod.Size(m)
}
func (m *HttpMethod) XXX_DiscardUnknown() {
	xxx_messageInfo_HttpMethod.DiscardUnknown(m)
}

var xxx_messageInfo_HttpMethod proto.InternalMessageInfo

type isHttpMethod_Type interface {
	isHttpMethod_Type()
}

type HttpMethod_Registered_ struct {
	Registered HttpMethod_Registered `protobuf:"varint,1,opt,name=registered,proto3,enum=linkerd2.public.HttpMethod_Registered,oneof"`
}

type HttpMethod_Unregistered struct {
	Unregistered string `protobuf:"bytes,2,opt,name=unregistered,proto3,oneof"`
}

func (*HttpMethod_Registered_) isHttpMethod_Type() {}

func (*HttpMethod_Unregistered) isHttpMethod_Type() {}

func (m *HttpMethod) GetType() isHttpMethod_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *HttpMethod) GetRegistered() HttpMethod_Registered {
	if x, ok := m.GetType().(*HttpMethod_Registered_); ok {
		return x.Registered
	}
	return HttpMethod_GET
}

func (m *HttpMethod) GetUnregistered() string {
	if x, ok := m.GetType().(*HttpMethod_Unregistered); ok {
		return x.Unregistered
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*HttpMethod) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _HttpMethod_OneofMarshaler, _HttpMethod_OneofUnmarshaler, _HttpMethod_OneofSizer, []interface{}{
		(*HttpMethod_Registered_)(nil),
		(*HttpMethod_Unregistered)(nil),
	}
}

func _HttpMethod_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*HttpMethod)
	// type
	switch x := m.Type.(type) {
	case *HttpMethod_Registered_:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Registered))
	case *HttpMethod_Unregistered:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Unregistered)
	case nil:
	default:
		return fmt.Errorf("HttpMethod.Type has unexpected type %T", x)
	}
	return nil
}

func _HttpMethod_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*HttpMethod)
	switch tag {
	case 1: // type.registered
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Type = &HttpMethod_Registered_{HttpMethod_Registered(x)}
		return true, err
	case 2: // type.unregistered
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Type = &HttpMethod_Unregistered{x}
		return true, err
	default:
		return false, nil
	}
}

func _HttpMethod_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*HttpMethod)
	// type
	switch x := m.Type.(type) {
	case *HttpMethod_Registered_:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Registered))
	case *HttpMethod_Unregistered:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Unregistered)))
		n += len(x.Unregistered)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Scheme struct {
	// Types that are valid to be assigned to Type:
	//	*Scheme_Registered_
	//	*Scheme_Unregistered
	Type                 isScheme_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Scheme) Reset()         { *m = Scheme{} }
func (m *Scheme) String() string { return proto.CompactTextString(m) }
func (*Scheme) ProtoMessage()    {}
func (*Scheme) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{8}
}
func (m *Scheme) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Scheme.Unmarshal(m, b)
}
func (m *Scheme) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Scheme.Marshal(b, m, deterministic)
}
func (dst *Scheme) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Scheme.Merge(dst, src)
}
func (m *Scheme) XXX_Size() int {
	return xxx_messageInfo_Scheme.Size(m)
}
func (m *Scheme) XXX_DiscardUnknown() {
	xxx_messageInfo_Scheme.DiscardUnknown(m)
}

var xxx_messageInfo_Scheme proto.InternalMessageInfo

type isScheme_Type interface {
	isScheme_Type()
}

type Scheme_Registered_ struct {
	Registered Scheme_Registered `protobuf:"varint,1,opt,name=registered,proto3,enum=linkerd2.public.Scheme_Registered,oneof"`
}

type Scheme_Unregistered struct {
	Unregistered string `protobuf:"bytes,2,opt,name=unregistered,proto3,oneof"`
}

func (*Scheme_Registered_) isScheme_Type() {}

func (*Scheme_Unregistered) isScheme_Type() {}

func (m *Scheme) GetType() isScheme_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Scheme) GetRegistered() Scheme_Registered {
	if x, ok := m.GetType().(*Scheme_Registered_); ok {
		return x.Registered
	}
	return Scheme_HTTP
}

func (m *Scheme) GetUnregistered() string {
	if x, ok := m.GetType().(*Scheme_Unregistered); ok {
		return x.Unregistered
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Scheme) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Scheme_OneofMarshaler, _Scheme_OneofUnmarshaler, _Scheme_OneofSizer, []interface{}{
		(*Scheme_Registered_)(nil),
		(*Scheme_Unregistered)(nil),
	}
}

func _Scheme_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Scheme)
	// type
	switch x := m.Type.(type) {
	case *Scheme_Registered_:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Registered))
	case *Scheme_Unregistered:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Unregistered)
	case nil:
	default:
		return fmt.Errorf("Scheme.Type has unexpected type %T", x)
	}
	return nil
}

func _Scheme_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Scheme)
	switch tag {
	case 1: // type.registered
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Type = &Scheme_Registered_{Scheme_Registered(x)}
		return true, err
	case 2: // type.unregistered
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Type = &Scheme_Unregistered{x}
		return true, err
	default:
		return false, nil
	}
}

func _Scheme_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Scheme)
	// type
	switch x := m.Type.(type) {
	case *Scheme_Registered_:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Registered))
	case *Scheme_Unregistered:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Unregistered)))
		n += len(x.Unregistered)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type IPAddress struct {
	// Types that are valid to be assigned to Ip:
	//	*IPAddress_Ipv4
	//	*IPAddress_Ipv6
	Ip                   isIPAddress_Ip `protobuf_oneof:"ip"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *IPAddress) Reset()         { *m = IPAddress{} }
func (m *IPAddress) String() string { return proto.CompactTextString(m) }
func (*IPAddress) ProtoMessage()    {}
func (*IPAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{9}
}
func (m *IPAddress) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IPAddress.Unmarshal(m, b)
}
func (m *IPAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IPAddress.Marshal(b, m, deterministic)
}
func (dst *IPAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPAddress.Merge(dst, src)
}
func (m *IPAddress) XXX_Size() int {
	return xxx_messageInfo_IPAddress.Size(m)
}
func (m *IPAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_IPAddress.DiscardUnknown(m)
}

var xxx_messageInfo_IPAddress proto.InternalMessageInfo

type isIPAddress_Ip interface {
	isIPAddress_Ip()
}

type IPAddress_Ipv4 struct {
	Ipv4 uint32 `protobuf:"fixed32,1,opt,name=ipv4,proto3,oneof"`
}

type IPAddress_Ipv6 struct {
	Ipv6 *IPv6 `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
}

func (*IPAddress_Ipv4) isIPAddress_Ip() {}

func (*IPAddress_Ipv6) isIPAddress_Ip() {}

func (m *IPAddress) GetIp() isIPAddress_Ip {
	if m != nil {
		return m.Ip
	}
	return nil
}

func (m *IPAddress) GetIpv4() uint32 {
	if x, ok := m.GetIp().(*IPAddress_Ipv4); ok {
		return x.Ipv4
	}
	return 0
}

func (m *IPAddress) GetIpv6() *IPv6 {
	if x, ok := m.GetIp().(*IPAddress_Ipv6); ok {
		return x.Ipv6
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*IPAddress) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _IPAddress_OneofMarshaler, _IPAddress_OneofUnmarshaler, _IPAddress_OneofSizer, []interface{}{
		(*IPAddress_Ipv4)(nil),
		(*IPAddress_Ipv6)(nil),
	}
}

func _IPAddress_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*IPAddress)
	// ip
	switch x := m.Ip.(type) {
	case *IPAddress_Ipv4:
		b.EncodeVarint(1<<3 | proto.WireFixed32)
		b.EncodeFixed32(uint64(x.Ipv4))
	case *IPAddress_Ipv6:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Ipv6); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("IPAddress.Ip has unexpected type %T", x)
	}
	return nil
}

func _IPAddress_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*IPAddress)
	switch tag {
	case 1: // ip.ipv4
		if wire != proto.WireFixed32 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed32()
		m.Ip = &IPAddress_Ipv4{uint32(x)}
		return true, err
	case 2: // ip.ipv6
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IPv6)
		err := b.DecodeMessage(msg)
		m.Ip = &IPAddress_Ipv6{msg}
		return true, err
	default:
		return false, nil
	}
}

func _IPAddress_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*IPAddress)
	// ip
	switch x := m.Ip.(type) {
	case *IPAddress_Ipv4:
		n += 1 // tag and wire
		n += 4
	case *IPAddress_Ipv6:
		s := proto.Size(x.Ipv6)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type IPv6 struct {
	First                uint64   `protobuf:"fixed64,1,opt,name=first,proto3" json:"first,omitempty"`
	Last                 uint64   `protobuf:"fixed64,2,opt,name=last,proto3" json:"last,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IPv6) Reset()         { *m = IPv6{} }
func (m *IPv6) String() string { return proto.CompactTextString(m) }
func (*IPv6) ProtoMessage()    {}
func (*IPv6) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{10}
}
func (m *IPv6) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IPv6.Unmarshal(m, b)
}
func (m *IPv6) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IPv6.Marshal(b, m, deterministic)
}
func (dst *IPv6) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPv6.Merge(dst, src)
}
func (m *IPv6) XXX_Size() int {
	return xxx_messageInfo_IPv6.Size(m)
}
func (m *IPv6) XXX_DiscardUnknown() {
	xxx_messageInfo_IPv6.DiscardUnknown(m)
}

var xxx_messageInfo_IPv6 proto.InternalMessageInfo

func (m *IPv6) GetFirst() uint64 {
	if m != nil {
		return m.First
	}
	return 0
}

func (m *IPv6) GetLast() uint64 {
	if m != nil {
		return m.Last
	}
	return 0
}

type TcpAddress struct {
	Ip                   *IPAddress `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Port                 uint32     `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *TcpAddress) Reset()         { *m = TcpAddress{} }
func (m *TcpAddress) String() string { return proto.CompactTextString(m) }
func (*TcpAddress) ProtoMessage()    {}
func (*TcpAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{11}
}
func (m *TcpAddress) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TcpAddress.Unmarshal(m, b)
}
func (m *TcpAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TcpAddress.Marshal(b, m, deterministic)
}
func (dst *TcpAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TcpAddress.Merge(dst, src)
}
func (m *TcpAddress) XXX_Size() int {
	return xxx_messageInfo_TcpAddress.Size(m)
}
func (m *TcpAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_TcpAddress.DiscardUnknown(m)
}

var xxx_messageInfo_TcpAddress proto.InternalMessageInfo

func (m *TcpAddress) GetIp() *IPAddress {
	if m != nil {
		return m.Ip
	}
	return nil
}

func (m *TcpAddress) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type Eos struct {
	// Types that are valid to be assigned to End:
	//	*Eos_GrpcStatusCode
	//	*Eos_ResetErrorCode
	End                  isEos_End `protobuf_oneof:"end"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Eos) Reset()         { *m = Eos{} }
func (m *Eos) String() string { return proto.CompactTextString(m) }
func (*Eos) ProtoMessage()    {}
func (*Eos) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{12}
}
func (m *Eos) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Eos.Unmarshal(m, b)
}
func (m *Eos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Eos.Marshal(b, m, deterministic)
}
func (dst *Eos) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Eos.Merge(dst, src)
}
func (m *Eos) XXX_Size() int {
	return xxx_messageInfo_Eos.Size(m)
}
func (m *Eos) XXX_DiscardUnknown() {
	xxx_messageInfo_Eos.DiscardUnknown(m)
}

var xxx_messageInfo_Eos proto.InternalMessageInfo

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() {}

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

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Eos) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Eos_OneofMarshaler, _Eos_OneofUnmarshaler, _Eos_OneofSizer, []interface{}{
		(*Eos_GrpcStatusCode)(nil),
		(*Eos_ResetErrorCode)(nil),
	}
}

func _Eos_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Eos)
	// end
	switch x := m.End.(type) {
	case *Eos_GrpcStatusCode:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.GrpcStatusCode))
	case *Eos_ResetErrorCode:
		b.EncodeVarint(2<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.ResetErrorCode))
	case nil:
	default:
		return fmt.Errorf("Eos.End has unexpected type %T", x)
	}
	return nil
}

func _Eos_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Eos)
	switch tag {
	case 1: // end.grpc_status_code
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.End = &Eos_GrpcStatusCode{uint32(x)}
		return true, err
	case 2: // end.reset_error_code
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.End = &Eos_ResetErrorCode{uint32(x)}
		return true, err
	default:
		return false, nil
	}
}

func _Eos_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Eos)
	// end
	switch x := m.End.(type) {
	case *Eos_GrpcStatusCode:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.GrpcStatusCode))
	case *Eos_ResetErrorCode:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.ResetErrorCode))
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TapEvent struct {
	Source          *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"`
	Destination     *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=linkerd2.public.TapEvent_ProxyDirection" json:"proxy_direction,omitempty"`
	// Types that are valid to be assigned to Event:
	//	*TapEvent_Http_
	Event                isTapEvent_Event `protobuf_oneof:"event"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *TapEvent) Reset()         { *m = TapEvent{} }
func (m *TapEvent) String() string { return proto.CompactTextString(m) }
func (*TapEvent) ProtoMessage()    {}
func (*TapEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13}
}
func (m *TapEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent.Unmarshal(m, b)
}
func (m *TapEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent.Marshal(b, m, deterministic)
}
func (dst *TapEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent.Merge(dst, src)
}
func (m *TapEvent) XXX_Size() int {
	return xxx_messageInfo_TapEvent.Size(m)
}
func (m *TapEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent proto.InternalMessageInfo

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

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

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

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

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

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() {}

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TapEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TapEvent_OneofMarshaler, _TapEvent_OneofUnmarshaler, _TapEvent_OneofSizer, []interface{}{
		(*TapEvent_Http_)(nil),
	}
}

func _TapEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TapEvent)
	// event
	switch x := m.Event.(type) {
	case *TapEvent_Http_:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Http); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TapEvent.Event has unexpected type %T", x)
	}
	return nil
}

func _TapEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TapEvent)
	switch tag {
	case 3: // event.http
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapEvent_Http)
		err := b.DecodeMessage(msg)
		m.Event = &TapEvent_Http_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TapEvent_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TapEvent)
	// event
	switch x := m.Event.(type) {
	case *TapEvent_Http_:
		s := proto.Size(x.Http)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TapEvent_EndpointMeta struct {
	Labels               map[string]string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *TapEvent_EndpointMeta) Reset()         { *m = TapEvent_EndpointMeta{} }
func (m *TapEvent_EndpointMeta) String() string { return proto.CompactTextString(m) }
func (*TapEvent_EndpointMeta) ProtoMessage()    {}
func (*TapEvent_EndpointMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 0}
}
func (m *TapEvent_EndpointMeta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent_EndpointMeta.Unmarshal(m, b)
}
func (m *TapEvent_EndpointMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent_EndpointMeta.Marshal(b, m, deterministic)
}
func (dst *TapEvent_EndpointMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent_EndpointMeta.Merge(dst, src)
}
func (m *TapEvent_EndpointMeta) XXX_Size() int {
	return xxx_messageInfo_TapEvent_EndpointMeta.Size(m)
}
func (m *TapEvent_EndpointMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent_EndpointMeta.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent_EndpointMeta proto.InternalMessageInfo

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

type TapEvent_Http struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *TapEvent_Http) Reset()         { *m = TapEvent_Http{} }
func (m *TapEvent_Http) String() string { return proto.CompactTextString(m) }
func (*TapEvent_Http) ProtoMessage()    {}
func (*TapEvent_Http) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 1}
}
func (m *TapEvent_Http) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent_Http.Unmarshal(m, b)
}
func (m *TapEvent_Http) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent_Http.Marshal(b, m, deterministic)
}
func (dst *TapEvent_Http) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent_Http.Merge(dst, src)
}
func (m *TapEvent_Http) XXX_Size() int {
	return xxx_messageInfo_TapEvent_Http.Size(m)
}
func (m *TapEvent_Http) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent_Http.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent_Http proto.InternalMessageInfo

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() {}

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

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

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TapEvent_Http) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TapEvent_Http_OneofMarshaler, _TapEvent_Http_OneofUnmarshaler, _TapEvent_Http_OneofSizer, []interface{}{
		(*TapEvent_Http_RequestInit_)(nil),
		(*TapEvent_Http_ResponseInit_)(nil),
		(*TapEvent_Http_ResponseEnd_)(nil),
	}
}

func _TapEvent_Http_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TapEvent_Http)
	// event
	switch x := m.Event.(type) {
	case *TapEvent_Http_RequestInit_:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RequestInit); err != nil {
			return err
		}
	case *TapEvent_Http_ResponseInit_:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResponseInit); err != nil {
			return err
		}
	case *TapEvent_Http_ResponseEnd_:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResponseEnd); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TapEvent_Http.Event has unexpected type %T", x)
	}
	return nil
}

func _TapEvent_Http_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TapEvent_Http)
	switch tag {
	case 1: // event.request_init
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapEvent_Http_RequestInit)
		err := b.DecodeMessage(msg)
		m.Event = &TapEvent_Http_RequestInit_{msg}
		return true, err
	case 2: // event.response_init
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapEvent_Http_ResponseInit)
		err := b.DecodeMessage(msg)
		m.Event = &TapEvent_Http_ResponseInit_{msg}
		return true, err
	case 3: // event.response_end
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TapEvent_Http_ResponseEnd)
		err := b.DecodeMessage(msg)
		m.Event = &TapEvent_Http_ResponseEnd_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TapEvent_Http_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TapEvent_Http)
	// event
	switch x := m.Event.(type) {
	case *TapEvent_Http_RequestInit_:
		s := proto.Size(x.RequestInit)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TapEvent_Http_ResponseInit_:
		s := proto.Size(x.ResponseInit)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TapEvent_Http_ResponseEnd_:
		s := proto.Size(x.ResponseEnd)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TapEvent_Http_StreamId struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TapEvent_Http_StreamId) Reset()         { *m = TapEvent_Http_StreamId{} }
func (m *TapEvent_Http_StreamId) String() string { return proto.CompactTextString(m) }
func (*TapEvent_Http_StreamId) ProtoMessage()    {}
func (*TapEvent_Http_StreamId) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 1, 0}
}
func (m *TapEvent_Http_StreamId) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent_Http_StreamId.Unmarshal(m, b)
}
func (m *TapEvent_Http_StreamId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent_Http_StreamId.Marshal(b, m, deterministic)
}
func (dst *TapEvent_Http_StreamId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent_Http_StreamId.Merge(dst, src)
}
func (m *TapEvent_Http_StreamId) XXX_Size() int {
	return xxx_messageInfo_TapEvent_Http_StreamId.Size(m)
}
func (m *TapEvent_Http_StreamId) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent_Http_StreamId.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent_Http_StreamId proto.InternalMessageInfo

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

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

type TapEvent_Http_RequestInit struct {
	Id                   *TapEvent_Http_StreamId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Method               *HttpMethod             `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
	Scheme               *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"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *TapEvent_Http_RequestInit) Reset()         { *m = TapEvent_Http_RequestInit{} }
func (m *TapEvent_Http_RequestInit) String() string { return proto.CompactTextString(m) }
func (*TapEvent_Http_RequestInit) ProtoMessage()    {}
func (*TapEvent_Http_RequestInit) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 1, 1}
}
func (m *TapEvent_Http_RequestInit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent_Http_RequestInit.Unmarshal(m, b)
}
func (m *TapEvent_Http_RequestInit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent_Http_RequestInit.Marshal(b, m, deterministic)
}
func (dst *TapEvent_Http_RequestInit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent_Http_RequestInit.Merge(dst, src)
}
func (m *TapEvent_Http_RequestInit) XXX_Size() int {
	return xxx_messageInfo_TapEvent_Http_RequestInit.Size(m)
}
func (m *TapEvent_Http_RequestInit) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent_Http_RequestInit.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent_Http_RequestInit proto.InternalMessageInfo

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

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

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

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

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

type TapEvent_Http_ResponseInit struct {
	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"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *TapEvent_Http_ResponseInit) Reset()         { *m = TapEvent_Http_ResponseInit{} }
func (m *TapEvent_Http_ResponseInit) String() string { return proto.CompactTextString(m) }
func (*TapEvent_Http_ResponseInit) ProtoMessage()    {}
func (*TapEvent_Http_ResponseInit) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 1, 2}
}
func (m *TapEvent_Http_ResponseInit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent_Http_ResponseInit.Unmarshal(m, b)
}
func (m *TapEvent_Http_ResponseInit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent_Http_ResponseInit.Marshal(b, m, deterministic)
}
func (dst *TapEvent_Http_ResponseInit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent_Http_ResponseInit.Merge(dst, src)
}
func (m *TapEvent_Http_ResponseInit) XXX_Size() int {
	return xxx_messageInfo_TapEvent_Http_ResponseInit.Size(m)
}
func (m *TapEvent_Http_ResponseInit) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent_Http_ResponseInit.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent_Http_ResponseInit proto.InternalMessageInfo

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

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

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

type TapEvent_Http_ResponseEnd struct {
	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"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *TapEvent_Http_ResponseEnd) Reset()         { *m = TapEvent_Http_ResponseEnd{} }
func (m *TapEvent_Http_ResponseEnd) String() string { return proto.CompactTextString(m) }
func (*TapEvent_Http_ResponseEnd) ProtoMessage()    {}
func (*TapEvent_Http_ResponseEnd) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{13, 1, 3}
}
func (m *TapEvent_Http_ResponseEnd) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TapEvent_Http_ResponseEnd.Unmarshal(m, b)
}
func (m *TapEvent_Http_ResponseEnd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TapEvent_Http_ResponseEnd.Marshal(b, m, deterministic)
}
func (dst *TapEvent_Http_ResponseEnd) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TapEvent_Http_ResponseEnd.Merge(dst, src)
}
func (m *TapEvent_Http_ResponseEnd) XXX_Size() int {
	return xxx_messageInfo_TapEvent_Http_ResponseEnd.Size(m)
}
func (m *TapEvent_Http_ResponseEnd) XXX_DiscardUnknown() {
	xxx_messageInfo_TapEvent_Http_ResponseEnd.DiscardUnknown(m)
}

var xxx_messageInfo_TapEvent_Http_ResponseEnd proto.InternalMessageInfo

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

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

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

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

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

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

func (m *ApiError) Reset()         { *m = ApiError{} }
func (m *ApiError) String() string { return proto.CompactTextString(m) }
func (*ApiError) ProtoMessage()    {}
func (*ApiError) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{14}
}
func (m *ApiError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ApiError.Unmarshal(m, b)
}
func (m *ApiError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ApiError.Marshal(b, m, deterministic)
}
func (dst *ApiError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApiError.Merge(dst, src)
}
func (m *ApiError) XXX_Size() int {
	return xxx_messageInfo_ApiError.Size(m)
}
func (m *ApiError) XXX_DiscardUnknown() {
	xxx_messageInfo_ApiError.DiscardUnknown(m)
}

var xxx_messageInfo_ApiError proto.InternalMessageInfo

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

type PodErrors struct {
	Errors               []*PodErrors_PodError `protobuf:"bytes,1,rep,name=errors,proto3" json:"errors,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *PodErrors) Reset()         { *m = PodErrors{} }
func (m *PodErrors) String() string { return proto.CompactTextString(m) }
func (*PodErrors) ProtoMessage()    {}
func (*PodErrors) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{15}
}
func (m *PodErrors) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PodErrors.Unmarshal(m, b)
}
func (m *PodErrors) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PodErrors.Marshal(b, m, deterministic)
}
func (dst *PodErrors) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodErrors.Merge(dst, src)
}
func (m *PodErrors) XXX_Size() int {
	return xxx_messageInfo_PodErrors.Size(m)
}
func (m *PodErrors) XXX_DiscardUnknown() {
	xxx_messageInfo_PodErrors.DiscardUnknown(m)
}

var xxx_messageInfo_PodErrors proto.InternalMessageInfo

func (m *PodErrors) GetErrors() []*PodErrors_PodError {
	if m != nil {
		return m.Errors
	}
	return nil
}

type PodErrors_PodError struct {
	// Types that are valid to be assigned to Error:
	//	*PodErrors_PodError_Container
	Error                isPodErrors_PodError_Error `protobuf_oneof:"error"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *PodErrors_PodError) Reset()         { *m = PodErrors_PodError{} }
func (m *PodErrors_PodError) String() string { return proto.CompactTextString(m) }
func (*PodErrors_PodError) ProtoMessage()    {}
func (*PodErrors_PodError) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{15, 0}
}
func (m *PodErrors_PodError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PodErrors_PodError.Unmarshal(m, b)
}
func (m *PodErrors_PodError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PodErrors_PodError.Marshal(b, m, deterministic)
}
func (dst *PodErrors_PodError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodErrors_PodError.Merge(dst, src)
}
func (m *PodErrors_PodError) XXX_Size() int {
	return xxx_messageInfo_PodErrors_PodError.Size(m)
}
func (m *PodErrors_PodError) XXX_DiscardUnknown() {
	xxx_messageInfo_PodErrors_PodError.DiscardUnknown(m)
}

var xxx_messageInfo_PodErrors_PodError proto.InternalMessageInfo

type isPodErrors_PodError_Error interface {
	isPodErrors_PodError_Error()
}

type PodErrors_PodError_Container struct {
	Container *PodErrors_PodError_ContainerError `protobuf:"bytes,1,opt,name=container,proto3,oneof"`
}

func (*PodErrors_PodError_Container) isPodErrors_PodError_Error() {}

func (m *PodErrors_PodError) GetError() isPodErrors_PodError_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *PodErrors_PodError) GetContainer() *PodErrors_PodError_ContainerError {
	if x, ok := m.GetError().(*PodErrors_PodError_Container); ok {
		return x.Container
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*PodErrors_PodError) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _PodErrors_PodError_OneofMarshaler, _PodErrors_PodError_OneofUnmarshaler, _PodErrors_PodError_OneofSizer, []interface{}{
		(*PodErrors_PodError_Container)(nil),
	}
}

func _PodErrors_PodError_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*PodErrors_PodError)
	// error
	switch x := m.Error.(type) {
	case *PodErrors_PodError_Container:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Container); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("PodErrors_PodError.Error has unexpected type %T", x)
	}
	return nil
}

func _PodErrors_PodError_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*PodErrors_PodError)
	switch tag {
	case 1: // error.container
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(PodErrors_PodError_ContainerError)
		err := b.DecodeMessage(msg)
		m.Error = &PodErrors_PodError_Container{msg}
		return true, err
	default:
		return false, nil
	}
}

func _PodErrors_PodError_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*PodErrors_PodError)
	// error
	switch x := m.Error.(type) {
	case *PodErrors_PodError_Container:
		s := proto.Size(x.Container)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// To report init-container and container failures
type PodErrors_PodError_ContainerError struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Container            string   `protobuf:"bytes,2,opt,name=container,proto3" json:"container,omitempty"`
	Image                string   `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"`
	Reason               string   `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PodErrors_PodError_ContainerError) Reset()         { *m = PodErrors_PodError_ContainerError{} }
func (m *PodErrors_PodError_ContainerError) String() string { return proto.CompactTextString(m) }
func (*PodErrors_PodError_ContainerError) ProtoMessage()    {}
func (*PodErrors_PodError_ContainerError) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{15, 0, 0}
}
func (m *PodErrors_PodError_ContainerError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PodErrors_PodError_ContainerError.Unmarshal(m, b)
}
func (m *PodErrors_PodError_ContainerError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PodErrors_PodError_ContainerError.Marshal(b, m, deterministic)
}
func (dst *PodErrors_PodError_ContainerError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodErrors_PodError_ContainerError.Merge(dst, src)
}
func (m *PodErrors_PodError_ContainerError) XXX_Size() int {
	return xxx_messageInfo_PodErrors_PodError_ContainerError.Size(m)
}
func (m *PodErrors_PodError_ContainerError) XXX_DiscardUnknown() {
	xxx_messageInfo_PodErrors_PodError_ContainerError.DiscardUnknown(m)
}

var xxx_messageInfo_PodErrors_PodError_ContainerError proto.InternalMessageInfo

func (m *PodErrors_PodError_ContainerError) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *PodErrors_PodError_ContainerError) GetContainer() string {
	if m != nil {
		return m.Container
	}
	return ""
}

func (m *PodErrors_PodError_ContainerError) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

func (m *PodErrors_PodError_ContainerError) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

type Resource struct {
	// The namespace the resource is in.
	//
	// If empty, indicates all namespaces should be considered.
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// The type of resource.
	//
	// This can be:
	// - "all" -- includes all Kubernetes resource types only
	// - "authority" -- a special resource type derived from request `:authority` values
	// - Otherwise, the resource type may be any Kubernetes resource (e.g. "namespace", "deployment").
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	// An optional resource name.
	Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Resource) Reset()         { *m = Resource{} }
func (m *Resource) String() string { return proto.CompactTextString(m) }
func (*Resource) ProtoMessage()    {}
func (*Resource) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{16}
}
func (m *Resource) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Resource.Unmarshal(m, b)
}
func (m *Resource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Resource.Marshal(b, m, deterministic)
}
func (dst *Resource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Resource.Merge(dst, src)
}
func (m *Resource) XXX_Size() int {
	return xxx_messageInfo_Resource.Size(m)
}
func (m *Resource) XXX_DiscardUnknown() {
	xxx_messageInfo_Resource.DiscardUnknown(m)
}

var xxx_messageInfo_Resource proto.InternalMessageInfo

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

func (m *Resource) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

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

type ResourceSelection struct {
	// Identifies a Kubernetes resource.
	Resource *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
	// A string-formatted Kubernetes label selector as passed to `kubectl get
	// --selector`.
	//
	// XXX in the future this may be superceded by a data structure that more
	// richly describes a parsed label selector.
	LabelSelector        string   `protobuf:"bytes,2,opt,name=label_selector,json=labelSelector,proto3" json:"label_selector,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ResourceSelection) Reset()         { *m = ResourceSelection{} }
func (m *ResourceSelection) String() string { return proto.CompactTextString(m) }
func (*ResourceSelection) ProtoMessage()    {}
func (*ResourceSelection) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{17}
}
func (m *ResourceSelection) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResourceSelection.Unmarshal(m, b)
}
func (m *ResourceSelection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResourceSelection.Marshal(b, m, deterministic)
}
func (dst *ResourceSelection) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceSelection.Merge(dst, src)
}
func (m *ResourceSelection) XXX_Size() int {
	return xxx_messageInfo_ResourceSelection.Size(m)
}
func (m *ResourceSelection) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceSelection.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceSelection proto.InternalMessageInfo

func (m *ResourceSelection) GetResource() *Resource {
	if m != nil {
		return m.Resource
	}
	return nil
}

func (m *ResourceSelection) GetLabelSelector() string {
	if m != nil {
		return m.LabelSelector
	}
	return ""
}

type ResourceError struct {
	Resource             *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
	Error                string    `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *ResourceError) Reset()         { *m = ResourceError{} }
func (m *ResourceError) String() string { return proto.CompactTextString(m) }
func (*ResourceError) ProtoMessage()    {}
func (*ResourceError) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{18}
}
func (m *ResourceError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResourceError.Unmarshal(m, b)
}
func (m *ResourceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResourceError.Marshal(b, m, deterministic)
}
func (dst *ResourceError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceError.Merge(dst, src)
}
func (m *ResourceError) XXX_Size() int {
	return xxx_messageInfo_ResourceError.Size(m)
}
func (m *ResourceError) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceError.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceError proto.InternalMessageInfo

func (m *ResourceError) GetResource() *Resource {
	if m != nil {
		return m.Resource
	}
	return nil
}

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

type StatSummaryRequest struct {
	Selector   *ResourceSelection `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
	TimeWindow string             `protobuf:"bytes,2,opt,name=time_window,json=timeWindow,proto3" json:"time_window,omitempty"`
	// Types that are valid to be assigned to Outbound:
	//	*StatSummaryRequest_None
	//	*StatSummaryRequest_ToResource
	//	*StatSummaryRequest_FromResource
	Outbound             isStatSummaryRequest_Outbound `protobuf_oneof:"outbound"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *StatSummaryRequest) Reset()         { *m = StatSummaryRequest{} }
func (m *StatSummaryRequest) String() string { return proto.CompactTextString(m) }
func (*StatSummaryRequest) ProtoMessage()    {}
func (*StatSummaryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{19}
}
func (m *StatSummaryRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatSummaryRequest.Unmarshal(m, b)
}
func (m *StatSummaryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatSummaryRequest.Marshal(b, m, deterministic)
}
func (dst *StatSummaryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatSummaryRequest.Merge(dst, src)
}
func (m *StatSummaryRequest) XXX_Size() int {
	return xxx_messageInfo_StatSummaryRequest.Size(m)
}
func (m *StatSummaryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StatSummaryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StatSummaryRequest proto.InternalMessageInfo

func (m *StatSummaryRequest) GetSelector() *ResourceSelection {
	if m != nil {
		return m.Selector
	}
	return nil
}

func (m *StatSummaryRequest) GetTimeWindow() string {
	if m != nil {
		return m.TimeWindow
	}
	return ""
}

type isStatSummaryRequest_Outbound interface {
	isStatSummaryRequest_Outbound()
}

type StatSummaryRequest_None struct {
	None *Empty `protobuf:"bytes,3,opt,name=none,proto3,oneof"`
}

type StatSummaryRequest_ToResource struct {
	ToResource *Resource `protobuf:"bytes,4,opt,name=to_resource,json=toResource,proto3,oneof"`
}

type StatSummaryRequest_FromResource struct {
	FromResource *Resource `protobuf:"bytes,5,opt,name=from_resource,json=fromResource,proto3,oneof"`
}

func (*StatSummaryRequest_None) isStatSummaryRequest_Outbound() {}

func (*StatSummaryRequest_ToResource) isStatSummaryRequest_Outbound() {}

func (*StatSummaryRequest_FromResource) isStatSummaryRequest_Outbound() {}

func (m *StatSummaryRequest) GetOutbound() isStatSummaryRequest_Outbound {
	if m != nil {
		return m.Outbound
	}
	return nil
}

func (m *StatSummaryRequest) GetNone() *Empty {
	if x, ok := m.GetOutbound().(*StatSummaryRequest_None); ok {
		return x.None
	}
	return nil
}

func (m *StatSummaryRequest) GetToResource() *Resource {
	if x, ok := m.GetOutbound().(*StatSummaryRequest_ToResource); ok {
		return x.ToResource
	}
	return nil
}

func (m *StatSummaryRequest) GetFromResource() *Resource {
	if x, ok := m.GetOutbound().(*StatSummaryRequest_FromResource); ok {
		return x.FromResource
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StatSummaryRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _StatSummaryRequest_OneofMarshaler, _StatSummaryRequest_OneofUnmarshaler, _StatSummaryRequest_OneofSizer, []interface{}{
		(*StatSummaryRequest_None)(nil),
		(*StatSummaryRequest_ToResource)(nil),
		(*StatSummaryRequest_FromResource)(nil),
	}
}

func _StatSummaryRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StatSummaryRequest)
	// outbound
	switch x := m.Outbound.(type) {
	case *StatSummaryRequest_None:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.None); err != nil {
			return err
		}
	case *StatSummaryRequest_ToResource:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ToResource); err != nil {
			return err
		}
	case *StatSummaryRequest_FromResource:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.FromResource); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StatSummaryRequest.Outbound has unexpected type %T", x)
	}
	return nil
}

func _StatSummaryRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StatSummaryRequest)
	switch tag {
	case 3: // outbound.none
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Empty)
		err := b.DecodeMessage(msg)
		m.Outbound = &StatSummaryRequest_None{msg}
		return true, err
	case 4: // outbound.to_resource
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Resource)
		err := b.DecodeMessage(msg)
		m.Outbound = &StatSummaryRequest_ToResource{msg}
		return true, err
	case 5: // outbound.from_resource
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Resource)
		err := b.DecodeMessage(msg)
		m.Outbound = &StatSummaryRequest_FromResource{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StatSummaryRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StatSummaryRequest)
	// outbound
	switch x := m.Outbound.(type) {
	case *StatSummaryRequest_None:
		s := proto.Size(x.None)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StatSummaryRequest_ToResource:
		s := proto.Size(x.ToResource)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StatSummaryRequest_FromResource:
		s := proto.Size(x.FromResource)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type StatSummaryResponse struct {
	// Types that are valid to be assigned to Response:
	//	*StatSummaryResponse_Ok_
	//	*StatSummaryResponse_Error
	Response             isStatSummaryResponse_Response `protobuf_oneof:"response"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

func (m *StatSummaryResponse) Reset()         { *m = StatSummaryResponse{} }
func (m *StatSummaryResponse) String() string { return proto.CompactTextString(m) }
func (*StatSummaryResponse) ProtoMessage()    {}
func (*StatSummaryResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{20}
}
func (m *StatSummaryResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatSummaryResponse.Unmarshal(m, b)
}
func (m *StatSummaryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatSummaryResponse.Marshal(b, m, deterministic)
}
func (dst *StatSummaryResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatSummaryResponse.Merge(dst, src)
}
func (m *StatSummaryResponse) XXX_Size() int {
	return xxx_messageInfo_StatSummaryResponse.Size(m)
}
func (m *StatSummaryResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StatSummaryResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StatSummaryResponse proto.InternalMessageInfo

type isStatSummaryResponse_Response interface {
	isStatSummaryResponse_Response()
}

type StatSummaryResponse_Ok_ struct {
	Ok *StatSummaryResponse_Ok `protobuf:"bytes,1,opt,name=ok,proto3,oneof"`
}

type StatSummaryResponse_Error struct {
	Error *ResourceError `protobuf:"bytes,2,opt,name=error,proto3,oneof"`
}

func (*StatSummaryResponse_Ok_) isStatSummaryResponse_Response() {}

func (*StatSummaryResponse_Error) isStatSummaryResponse_Response() {}

func (m *StatSummaryResponse) GetResponse() isStatSummaryResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *StatSummaryResponse) GetOk() *StatSummaryResponse_Ok {
	if x, ok := m.GetResponse().(*StatSummaryResponse_Ok_); ok {
		return x.Ok
	}
	return nil
}

func (m *StatSummaryResponse) GetError() *ResourceError {
	if x, ok := m.GetResponse().(*StatSummaryResponse_Error); ok {
		return x.Error
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StatSummaryResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _StatSummaryResponse_OneofMarshaler, _StatSummaryResponse_OneofUnmarshaler, _StatSummaryResponse_OneofSizer, []interface{}{
		(*StatSummaryResponse_Ok_)(nil),
		(*StatSummaryResponse_Error)(nil),
	}
}

func _StatSummaryResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StatSummaryResponse)
	// response
	switch x := m.Response.(type) {
	case *StatSummaryResponse_Ok_:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Ok); err != nil {
			return err
		}
	case *StatSummaryResponse_Error:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StatSummaryResponse.Response has unexpected type %T", x)
	}
	return nil
}

func _StatSummaryResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StatSummaryResponse)
	switch tag {
	case 1: // response.ok
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatSummaryResponse_Ok)
		err := b.DecodeMessage(msg)
		m.Response = &StatSummaryResponse_Ok_{msg}
		return true, err
	case 2: // response.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResourceError)
		err := b.DecodeMessage(msg)
		m.Response = &StatSummaryResponse_Error{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StatSummaryResponse_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StatSummaryResponse)
	// response
	switch x := m.Response.(type) {
	case *StatSummaryResponse_Ok_:
		s := proto.Size(x.Ok)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StatSummaryResponse_Error:
		s := proto.Size(x.Error)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type StatSummaryResponse_Ok struct {
	StatTables           []*StatTable `protobuf:"bytes,1,rep,name=stat_tables,json=statTables,proto3" json:"stat_tables,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *StatSummaryResponse_Ok) Reset()         { *m = StatSummaryResponse_Ok{} }
func (m *StatSummaryResponse_Ok) String() string { return proto.CompactTextString(m) }
func (*StatSummaryResponse_Ok) ProtoMessage()    {}
func (*StatSummaryResponse_Ok) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{20, 0}
}
func (m *StatSummaryResponse_Ok) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatSummaryResponse_Ok.Unmarshal(m, b)
}
func (m *StatSummaryResponse_Ok) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatSummaryResponse_Ok.Marshal(b, m, deterministic)
}
func (dst *StatSummaryResponse_Ok) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatSummaryResponse_Ok.Merge(dst, src)
}
func (m *StatSummaryResponse_Ok) XXX_Size() int {
	return xxx_messageInfo_StatSummaryResponse_Ok.Size(m)
}
func (m *StatSummaryResponse_Ok) XXX_DiscardUnknown() {
	xxx_messageInfo_StatSummaryResponse_Ok.DiscardUnknown(m)
}

var xxx_messageInfo_StatSummaryResponse_Ok proto.InternalMessageInfo

func (m *StatSummaryResponse_Ok) GetStatTables() []*StatTable {
	if m != nil {
		return m.StatTables
	}
	return nil
}

type BasicStats struct {
	SuccessCount         uint64   `protobuf:"varint,1,opt,name=success_count,json=successCount,proto3" json:"success_count,omitempty"`
	FailureCount         uint64   `protobuf:"varint,2,opt,name=failure_count,json=failureCount,proto3" json:"failure_count,omitempty"`
	LatencyMsP50         uint64   `protobuf:"varint,3,opt,name=latency_ms_p50,json=latencyMsP50,proto3" json:"latency_ms_p50,omitempty"`
	LatencyMsP95         uint64   `protobuf:"varint,4,opt,name=latency_ms_p95,json=latencyMsP95,proto3" json:"latency_ms_p95,omitempty"`
	LatencyMsP99         uint64   `protobuf:"varint,5,opt,name=latency_ms_p99,json=latencyMsP99,proto3" json:"latency_ms_p99,omitempty"`
	TlsRequestCount      uint64   `protobuf:"varint,6,opt,name=tls_request_count,json=tlsRequestCount,proto3" json:"tls_request_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BasicStats) Reset()         { *m = BasicStats{} }
func (m *BasicStats) String() string { return proto.CompactTextString(m) }
func (*BasicStats) ProtoMessage()    {}
func (*BasicStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{21}
}
func (m *BasicStats) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BasicStats.Unmarshal(m, b)
}
func (m *BasicStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BasicStats.Marshal(b, m, deterministic)
}
func (dst *BasicStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BasicStats.Merge(dst, src)
}
func (m *BasicStats) XXX_Size() int {
	return xxx_messageInfo_BasicStats.Size(m)
}
func (m *BasicStats) XXX_DiscardUnknown() {
	xxx_messageInfo_BasicStats.DiscardUnknown(m)
}

var xxx_messageInfo_BasicStats proto.InternalMessageInfo

func (m *BasicStats) GetSuccessCount() uint64 {
	if m != nil {
		return m.SuccessCount
	}
	return 0
}

func (m *BasicStats) GetFailureCount() uint64 {
	if m != nil {
		return m.FailureCount
	}
	return 0
}

func (m *BasicStats) GetLatencyMsP50() uint64 {
	if m != nil {
		return m.LatencyMsP50
	}
	return 0
}

func (m *BasicStats) GetLatencyMsP95() uint64 {
	if m != nil {
		return m.LatencyMsP95
	}
	return 0
}

func (m *BasicStats) GetLatencyMsP99() uint64 {
	if m != nil {
		return m.LatencyMsP99
	}
	return 0
}

func (m *BasicStats) GetTlsRequestCount() uint64 {
	if m != nil {
		return m.TlsRequestCount
	}
	return 0
}

type StatTable struct {
	// Types that are valid to be assigned to Table:
	//	*StatTable_PodGroup_
	Table                isStatTable_Table `protobuf_oneof:"table"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *StatTable) Reset()         { *m = StatTable{} }
func (m *StatTable) String() string { return proto.CompactTextString(m) }
func (*StatTable) ProtoMessage()    {}
func (*StatTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{22}
}
func (m *StatTable) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatTable.Unmarshal(m, b)
}
func (m *StatTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatTable.Marshal(b, m, deterministic)
}
func (dst *StatTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatTable.Merge(dst, src)
}
func (m *StatTable) XXX_Size() int {
	return xxx_messageInfo_StatTable.Size(m)
}
func (m *StatTable) XXX_DiscardUnknown() {
	xxx_messageInfo_StatTable.DiscardUnknown(m)
}

var xxx_messageInfo_StatTable proto.InternalMessageInfo

type isStatTable_Table interface {
	isStatTable_Table()
}

type StatTable_PodGroup_ struct {
	PodGroup *StatTable_PodGroup `protobuf:"bytes,1,opt,name=pod_group,json=podGroup,proto3,oneof"`
}

func (*StatTable_PodGroup_) isStatTable_Table() {}

func (m *StatTable) GetTable() isStatTable_Table {
	if m != nil {
		return m.Table
	}
	return nil
}

func (m *StatTable) GetPodGroup() *StatTable_PodGroup {
	if x, ok := m.GetTable().(*StatTable_PodGroup_); ok {
		return x.PodGroup
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StatTable) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _StatTable_OneofMarshaler, _StatTable_OneofUnmarshaler, _StatTable_OneofSizer, []interface{}{
		(*StatTable_PodGroup_)(nil),
	}
}

func _StatTable_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StatTable)
	// table
	switch x := m.Table.(type) {
	case *StatTable_PodGroup_:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PodGroup); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StatTable.Table has unexpected type %T", x)
	}
	return nil
}

func _StatTable_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StatTable)
	switch tag {
	case 1: // table.pod_group
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatTable_PodGroup)
		err := b.DecodeMessage(msg)
		m.Table = &StatTable_PodGroup_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StatTable_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StatTable)
	// table
	switch x := m.Table.(type) {
	case *StatTable_PodGroup_:
		s := proto.Size(x.PodGroup)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type StatTable_PodGroup struct {
	Rows                 []*StatTable_PodGroup_Row `protobuf:"bytes,1,rep,name=rows,proto3" json:"rows,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *StatTable_PodGroup) Reset()         { *m = StatTable_PodGroup{} }
func (m *StatTable_PodGroup) String() string { return proto.CompactTextString(m) }
func (*StatTable_PodGroup) ProtoMessage()    {}
func (*StatTable_PodGroup) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{22, 0}
}
func (m *StatTable_PodGroup) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatTable_PodGroup.Unmarshal(m, b)
}
func (m *StatTable_PodGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatTable_PodGroup.Marshal(b, m, deterministic)
}
func (dst *StatTable_PodGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatTable_PodGroup.Merge(dst, src)
}
func (m *StatTable_PodGroup) XXX_Size() int {
	return xxx_messageInfo_StatTable_PodGroup.Size(m)
}
func (m *StatTable_PodGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_StatTable_PodGroup.DiscardUnknown(m)
}

var xxx_messageInfo_StatTable_PodGroup proto.InternalMessageInfo

func (m *StatTable_PodGroup) GetRows() []*StatTable_PodGroup_Row {
	if m != nil {
		return m.Rows
	}
	return nil
}

type StatTable_PodGroup_Row struct {
	Resource   *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
	TimeWindow string    `protobuf:"bytes,2,opt,name=time_window,json=timeWindow,proto3" json:"time_window,omitempty"`
	// number of pending or running pods in this resource that have linkerd injected
	MeshedPodCount uint64 `protobuf:"varint,3,opt,name=meshed_pod_count,json=meshedPodCount,proto3" json:"meshed_pod_count,omitempty"`
	// number of pending or running pods in this resource
	RunningPodCount uint64 `protobuf:"varint,4,opt,name=running_pod_count,json=runningPodCount,proto3" json:"running_pod_count,omitempty"`
	// number of pods in this resource that have Phase PodFailed
	FailedPodCount uint64      `protobuf:"varint,6,opt,name=failed_pod_count,json=failedPodCount,proto3" json:"failed_pod_count,omitempty"`
	Stats          *BasicStats `protobuf:"bytes,5,opt,name=stats,proto3" json:"stats,omitempty"`
	// Stores a set of errors for each pod name. If a pod has no errors, it may be omitted.
	ErrorsByPod          map[string]*PodErrors `protobuf:"bytes,7,rep,name=errors_by_pod,json=errorsByPod,proto3" json:"errors_by_pod,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *StatTable_PodGroup_Row) Reset()         { *m = StatTable_PodGroup_Row{} }
func (m *StatTable_PodGroup_Row) String() string { return proto.CompactTextString(m) }
func (*StatTable_PodGroup_Row) ProtoMessage()    {}
func (*StatTable_PodGroup_Row) Descriptor() ([]byte, []int) {
	return fileDescriptor_public_62da165bc60d64f8, []int{22, 0, 0}
}
func (m *StatTable_PodGroup_Row) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatTable_PodGroup_Row.Unmarshal(m, b)
}
func (m *StatTable_PodGroup_Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatTable_PodGroup_Row.Marshal(b, m, deterministic)
}
func (dst *StatTable_PodGroup_Row) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatTable_PodGroup_Row.Merge(dst, src)
}
func (m *StatTable_PodGroup_Row) XXX_Size() int {
	return xxx_messageInfo_StatTable_PodGroup_Row.Size(m)
}
func (m *StatTable_PodGroup_Row) XXX_DiscardUnknown() {
	xxx_messageInfo_StatTable_PodGroup_Row.DiscardUnknown(m)
}

var xxx_messageInfo_StatTable_PodGroup_Row proto.InternalMessageInfo

func (m *StatTable_PodGroup_Row) GetResource() *Resource {
	if m != nil {
		return m.Resource
	}
	return nil
}

func (m *StatTable_PodGroup_Row) GetTimeWindow() string {
	if m != nil {
		return m.TimeWindow
	}
	return ""
}

func (m *StatTable_PodGroup_Row) GetMeshedPodCount() uint64 {
	if m != nil {
		return m.MeshedPodCount
	}
	return 0
}

func (m *StatTable_PodGroup_Row) GetRunningPodCount() uint64 {
	if m != nil {
		return m.RunningPodCount
	}
	return 0
}

func (m *StatTable_PodGroup_Row) GetFailedPodCount() uint64 {
	if m != nil {
		return m.FailedPodCount
	}
	return 0
}

func (m *StatTable_PodGroup_Row) GetStats() *BasicStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func (m *StatTable_PodGroup_Row) GetErrorsByPod() map[string]*PodErrors {
	if m != nil {
		return m.ErrorsByPod
	}
	return nil
}

func init() {
	proto.RegisterType((*Empty)(nil), "linkerd2.public.Empty")
	proto.RegisterType((*VersionInfo)(nil), "linkerd2.public.VersionInfo")
	proto.RegisterType((*ListPodsRequest)(nil), "linkerd2.public.ListPodsRequest")
	proto.RegisterType((*ListPodsResponse)(nil), "linkerd2.public.ListPodsResponse")
	proto.RegisterType((*Pod)(nil), "linkerd2.public.Pod")
	proto.RegisterType((*TapRequest)(nil), "linkerd2.public.TapRequest")
	proto.RegisterType((*TapByResourceRequest)(nil), "linkerd2.public.TapByResourceRequest")
	proto.RegisterType((*TapByResourceRequest_Match)(nil), "linkerd2.public.TapByResourceRequest.Match")
	proto.RegisterType((*TapByResourceRequest_Match_Seq)(nil), "linkerd2.public.TapByResourceRequest.Match.Seq")
	proto.RegisterType((*TapByResourceRequest_Match_Http)(nil), "linkerd2.public.TapByResourceRequest.Match.Http")
	proto.RegisterType((*HttpMethod)(nil), "linkerd2.public.HttpMethod")
	proto.RegisterType((*Scheme)(nil), "linkerd2.public.Scheme")
	proto.RegisterType((*IPAddress)(nil), "linkerd2.public.IPAddress")
	proto.RegisterType((*IPv6)(nil), "linkerd2.public.IPv6")
	proto.RegisterType((*TcpAddress)(nil), "linkerd2.public.TcpAddress")
	proto.RegisterType((*Eos)(nil), "linkerd2.public.Eos")
	proto.RegisterType((*TapEvent)(nil), "linkerd2.public.TapEvent")
	proto.RegisterType((*TapEvent_EndpointMeta)(nil), "linkerd2.public.TapEvent.EndpointMeta")
	proto.RegisterMapType((map[string]string)(nil), "linkerd2.public.TapEvent.EndpointMeta.LabelsEntry")
	proto.RegisterType((*TapEvent_Http)(nil), "linkerd2.public.TapEvent.Http")
	proto.RegisterType((*TapEvent_Http_StreamId)(nil), "linkerd2.public.TapEvent.Http.StreamId")
	proto.RegisterType((*TapEvent_Http_RequestInit)(nil), "linkerd2.public.TapEvent.Http.RequestInit")
	proto.RegisterType((*TapEvent_Http_ResponseInit)(nil), "linkerd2.public.TapEvent.Http.ResponseInit")
	proto.RegisterType((*TapEvent_Http_ResponseEnd)(nil), "linkerd2.public.TapEvent.Http.ResponseEnd")
	proto.RegisterType((*ApiError)(nil), "linkerd2.public.ApiError")
	proto.RegisterType((*PodErrors)(nil), "linkerd2.public.PodErrors")
	proto.RegisterType((*PodErrors_PodError)(nil), "linkerd2.public.PodErrors.PodError")
	proto.RegisterType((*PodErrors_PodError_ContainerError)(nil), "linkerd2.public.PodErrors.PodError.ContainerError")
	proto.RegisterType((*Resource)(nil), "linkerd2.public.Resource")
	proto.RegisterType((*ResourceSelection)(nil), "linkerd2.public.ResourceSelection")
	proto.RegisterType((*ResourceError)(nil), "linkerd2.public.ResourceError")
	proto.RegisterType((*StatSummaryRequest)(nil), "linkerd2.public.StatSummaryRequest")
	proto.RegisterType((*StatSummaryResponse)(nil), "linkerd2.public.StatSummaryResponse")
	proto.RegisterType((*StatSummaryResponse_Ok)(nil), "linkerd2.public.StatSummaryResponse.Ok")
	proto.RegisterType((*BasicStats)(nil), "linkerd2.public.BasicStats")
	proto.RegisterType((*StatTable)(nil), "linkerd2.public.StatTable")
	proto.RegisterType((*StatTable_PodGroup)(nil), "linkerd2.public.StatTable.PodGroup")
	proto.RegisterType((*StatTable_PodGroup_Row)(nil), "linkerd2.public.StatTable.PodGroup.Row")
	proto.RegisterMapType((map[string]*PodErrors)(nil), "linkerd2.public.StatTable.PodGroup.Row.ErrorsByPodEntry")
	proto.RegisterEnum("linkerd2.public.HttpMethod_Registered", HttpMethod_Registered_name, HttpMethod_Registered_value)
	proto.RegisterEnum("linkerd2.public.Scheme_Registered", Scheme_Registered_name, Scheme_Registered_value)
	proto.RegisterEnum("linkerd2.public.TapEvent_ProxyDirection", TapEvent_ProxyDirection_name, TapEvent_ProxyDirection_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ApiClient is the client API for Api service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApiClient interface {
	StatSummary(ctx context.Context, in *StatSummaryRequest, opts ...grpc.CallOption) (*StatSummaryResponse, error)
	ListPods(ctx context.Context, in *ListPodsRequest, opts ...grpc.CallOption) (*ListPodsResponse, error)
	// Superceded by `TapByResource`.
	Tap(ctx context.Context, in *TapRequest, opts ...grpc.CallOption) (Api_TapClient, error)
	// Executes tapping over Kubernetes resources.
	TapByResource(ctx context.Context, in *TapByResourceRequest, opts ...grpc.CallOption) (Api_TapByResourceClient, error)
	Version(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*VersionInfo, error)
	SelfCheck(ctx context.Context, in *healthcheck.SelfCheckRequest, opts ...grpc.CallOption) (*healthcheck.SelfCheckResponse, error)
}

type apiClient struct {
	cc *grpc.ClientConn
}

func NewApiClient(cc *grpc.ClientConn) ApiClient {
	return &apiClient{cc}
}

func (c *apiClient) StatSummary(ctx context.Context, in *StatSummaryRequest, opts ...grpc.CallOption) (*StatSummaryResponse, error) {
	out := new(StatSummaryResponse)
	err := c.cc.Invoke(ctx, "/linkerd2.public.Api/StatSummary", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) ListPods(ctx context.Context, in *ListPodsRequest, opts ...grpc.CallOption) (*ListPodsResponse, error) {
	out := new(ListPodsResponse)
	err := c.cc.Invoke(ctx, "/linkerd2.public.Api/ListPods", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *apiClient) Tap(ctx context.Context, in *TapRequest, opts ...grpc.CallOption) (Api_TapClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Api_serviceDesc.Streams[0], "/linkerd2.public.Api/Tap", opts...)
	if err != nil {
		return nil, err
	}
	x := &apiTapClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Api_TapClient interface {
	Recv() (*TapEvent, error)
	grpc.ClientStream
}

type apiTapClient struct {
	grpc.ClientStream
}

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

func (c *apiClient) TapByResource(ctx context.Context, in *TapByResourceRequest, opts ...grpc.CallOption) (Api_TapByResourceClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Api_serviceDesc.Streams[1], "/linkerd2.public.Api/TapByResource", opts...)
	if err != nil {
		return nil, err
	}
	x := &apiTapByResourceClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Api_TapByResourceClient interface {
	Recv() (*TapEvent, error)
	grpc.ClientStream
}

type apiTapByResourceClient struct {
	grpc.ClientStream
}

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

func (c *apiClient) Version(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*VersionInfo, error) {
	out := new(VersionInfo)
	err := c.cc.Invoke(ctx, "/linkerd2.public.Api/Version", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) SelfCheck(ctx context.Context, in *healthcheck.SelfCheckRequest, opts ...grpc.CallOption) (*healthcheck.SelfCheckResponse, error) {
	out := new(healthcheck.SelfCheckResponse)
	err := c.cc.Invoke(ctx, "/linkerd2.public.Api/SelfCheck", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApiServer is the server API for Api service.
type ApiServer interface {
	StatSummary(context.Context, *StatSummaryRequest) (*StatSummaryResponse, error)
	ListPods(context.Context, *ListPodsRequest) (*ListPodsResponse, error)
	// Superceded by `TapByResource`.
	Tap(*TapRequest, Api_TapServer) error
	// Executes tapping over Kubernetes resources.
	TapByResource(*TapByResourceRequest, Api_TapByResourceServer) error
	Version(context.Context, *Empty) (*VersionInfo, error)
	SelfCheck(context.Context, *healthcheck.SelfCheckRequest) (*healthcheck.SelfCheckResponse, error)
}

func RegisterApiServer(s *grpc.Server, srv ApiServer) {
	s.RegisterService(&_Api_serviceDesc, srv)
}

func _Api_StatSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatSummaryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).StatSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/linkerd2.public.Api/StatSummary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).StatSummary(ctx, req.(*StatSummaryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Api_ListPods_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPodsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).ListPods(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/linkerd2.public.Api/ListPods",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).ListPods(ctx, req.(*ListPodsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Api_Tap_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TapRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiServer).Tap(m, &apiTapServer{stream})
}

type Api_TapServer interface {
	Send(*TapEvent) error
	grpc.ServerStream
}

type apiTapServer struct {
	grpc.ServerStream
}

func (x *apiTapServer) Send(m *TapEvent) error {
	return x.ServerStream.SendMsg(m)
}

func _Api_TapByResource_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TapByResourceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiServer).TapByResource(m, &apiTapByResourceServer{stream})
}

type Api_TapByResourceServer interface {
	Send(*TapEvent) error
	grpc.ServerStream
}

type apiTapByResourceServer struct {
	grpc.ServerStream
}

func (x *apiTapByResourceServer) Send(m *TapEvent) error {
	return x.ServerStream.SendMsg(m)
}

func _Api_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/linkerd2.public.Api/Version",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).Version(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Api_SelfCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(healthcheck.SelfCheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).SelfCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/linkerd2.public.Api/SelfCheck",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).SelfCheck(ctx, req.(*healthcheck.SelfCheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Api_serviceDesc = grpc.ServiceDesc{
	ServiceName: "linkerd2.public.Api",
	HandlerType: (*ApiServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StatSummary",
			Handler:    _Api_StatSummary_Handler,
		},
		{
			MethodName: "ListPods",
			Handler:    _Api_ListPods_Handler,
		},
		{
			MethodName: "Version",
			Handler:    _Api_Version_Handler,
		},
		{
			MethodName: "SelfCheck",
			Handler:    _Api_SelfCheck_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Tap",
			Handler:       _Api_Tap_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "TapByResource",
			Handler:       _Api_TapByResource_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "public.proto",
}

func init() { proto.RegisterFile("public.proto", fileDescriptor_public_62da165bc60d64f8) }

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