linkerd2-proxy-api 0.18.0

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

package destination

import (
	duration "github.com/golang/protobuf/ptypes/duration"
	http_types "github.com/linkerd/linkerd2-proxy-api/go/http_types"
	meta "github.com/linkerd/linkerd2-proxy-api/go/meta"
	net "github.com/linkerd/linkerd2-proxy-api/go/net"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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

type GetDestination struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	Scheme string                 `protobuf:"bytes,1,opt,name=scheme,proto3" json:"scheme,omitempty"`
	Path   string                 `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// An opaque value that is set at injection-time and sent with destintion
	// lookups.
	//
	// If, for instance, the token encodes a namespace or some locality
	// information, the service may alter its results to take this locality into
	// account.
	ContextToken  string `protobuf:"bytes,3,opt,name=context_token,json=contextToken,proto3" json:"context_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetDestination) ProtoMessage() {}

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

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

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

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

func (x *GetDestination) GetContextToken() string {
	if x != nil {
		return x.ContextToken
	}
	return ""
}

type Update struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Update:
	//
	//	*Update_Add
	//	*Update_Remove
	//	*Update_NoEndpoints
	Update        isUpdate_Update `protobuf_oneof:"update"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Update) ProtoMessage() {}

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

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

func (x *Update) GetUpdate() isUpdate_Update {
	if x != nil {
		return x.Update
	}
	return nil
}

func (x *Update) GetAdd() *WeightedAddrSet {
	if x != nil {
		if x, ok := x.Update.(*Update_Add); ok {
			return x.Add
		}
	}
	return nil
}

func (x *Update) GetRemove() *AddrSet {
	if x != nil {
		if x, ok := x.Update.(*Update_Remove); ok {
			return x.Remove
		}
	}
	return nil
}

func (x *Update) GetNoEndpoints() *NoEndpoints {
	if x != nil {
		if x, ok := x.Update.(*Update_NoEndpoints); ok {
			return x.NoEndpoints
		}
	}
	return nil
}

type isUpdate_Update interface {
	isUpdate_Update()
}

type Update_Add struct {
	// A new set of endpoints are available for the service. The set might be
	// empty.
	Add *WeightedAddrSet `protobuf:"bytes,1,opt,name=add,proto3,oneof"`
}

type Update_Remove struct {
	// Some endpoints have been removed from the service.
	Remove *AddrSet `protobuf:"bytes,2,opt,name=remove,proto3,oneof"`
}

type Update_NoEndpoints struct {
	// `no_endpoints{exists: false}` indicates that the service does not exist
	// and the client MAY try an alternate service discovery method (e.g. DNS).
	//
	// `no_endpoints(exists: true)` indicates that the service does exist and
	// the client MUST NOT fall back to an alternate service discovery method.
	NoEndpoints *NoEndpoints `protobuf:"bytes,3,opt,name=no_endpoints,json=noEndpoints,proto3,oneof"`
}

func (*Update_Add) isUpdate_Update() {}

func (*Update_Remove) isUpdate_Update() {}

func (*Update_NoEndpoints) isUpdate_Update() {}

type AddrSet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Addrs         []*net.TcpAddress      `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AddrSet) ProtoMessage() {}

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

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

func (x *AddrSet) GetAddrs() []*net.TcpAddress {
	if x != nil {
		return x.Addrs
	}
	return nil
}

type WeightedAddrSet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Addrs         []*WeightedAddr        `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
	MetricLabels  map[string]string      `protobuf:"bytes,2,rep,name=metric_labels,json=metricLabels,proto3" json:"metric_labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WeightedAddrSet) ProtoMessage() {}

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

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

func (x *WeightedAddrSet) GetAddrs() []*WeightedAddr {
	if x != nil {
		return x.Addrs
	}
	return nil
}

func (x *WeightedAddrSet) GetMetricLabels() map[string]string {
	if x != nil {
		return x.MetricLabels
	}
	return nil
}

type WeightedAddr struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	Addr              *net.TcpAddress        `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Weight            uint32                 `protobuf:"varint,3,opt,name=weight,proto3" json:"weight,omitempty"`
	MetricLabels      map[string]string      `protobuf:"bytes,4,rep,name=metric_labels,json=metricLabels,proto3" json:"metric_labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	TlsIdentity       *TlsIdentity           `protobuf:"bytes,5,opt,name=tls_identity,json=tlsIdentity,proto3" json:"tls_identity,omitempty"`
	ProtocolHint      *ProtocolHint          `protobuf:"bytes,6,opt,name=protocol_hint,json=protocolHint,proto3" json:"protocol_hint,omitempty"`
	AuthorityOverride *AuthorityOverride     `protobuf:"bytes,7,opt,name=authority_override,json=authorityOverride,proto3" json:"authority_override,omitempty"`
	// The HTTP/2 parameters to use when connecting to the destination, if HTTP/2
	// is used. These parameters are used by proxies when the application traffic
	// is HTTP/2 or when the H2 ProtocolHint is used to transport HTTP/1
	// connections over HTTP/2.
	Http2 *Http2ClientParams `protobuf:"bytes,8,opt,name=http2,proto3" json:"http2,omitempty"`
	// A reference to the metadata for this endpoint, usually a Pod. This may be
	// omitted when the resource type is unknown.
	ResourceRef   *meta.Metadata `protobuf:"bytes,9,opt,name=resource_ref,json=resourceRef,proto3" json:"resource_ref,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WeightedAddr) ProtoMessage() {}

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

// Deprecated: Use WeightedAddr.ProtoReflect.Descriptor instead.
func (*WeightedAddr) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{4}
}

func (x *WeightedAddr) GetAddr() *net.TcpAddress {
	if x != nil {
		return x.Addr
	}
	return nil
}

func (x *WeightedAddr) GetWeight() uint32 {
	if x != nil {
		return x.Weight
	}
	return 0
}

func (x *WeightedAddr) GetMetricLabels() map[string]string {
	if x != nil {
		return x.MetricLabels
	}
	return nil
}

func (x *WeightedAddr) GetTlsIdentity() *TlsIdentity {
	if x != nil {
		return x.TlsIdentity
	}
	return nil
}

func (x *WeightedAddr) GetProtocolHint() *ProtocolHint {
	if x != nil {
		return x.ProtocolHint
	}
	return nil
}

func (x *WeightedAddr) GetAuthorityOverride() *AuthorityOverride {
	if x != nil {
		return x.AuthorityOverride
	}
	return nil
}

func (x *WeightedAddr) GetHttp2() *Http2ClientParams {
	if x != nil {
		return x.Http2
	}
	return nil
}

func (x *WeightedAddr) GetResourceRef() *meta.Metadata {
	if x != nil {
		return x.ResourceRef
	}
	return nil
}

type TlsIdentity struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Strategy:
	//
	//	*TlsIdentity_DnsLikeIdentity_
	//	*TlsIdentity_UriLikeIdentity_
	Strategy isTlsIdentity_Strategy `protobuf_oneof:"strategy"`
	// The server name of the endpoint. This is the value that needs to be included
	// by clients in the ClientHello SNI extension of the TLS handshake when they
	// initiate TLS connections to servers.
	ServerName    *TlsIdentity_DnsLikeIdentity `protobuf:"bytes,4,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TlsIdentity) ProtoMessage() {}

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

// Deprecated: Use TlsIdentity.ProtoReflect.Descriptor instead.
func (*TlsIdentity) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{5}
}

func (x *TlsIdentity) GetStrategy() isTlsIdentity_Strategy {
	if x != nil {
		return x.Strategy
	}
	return nil
}

func (x *TlsIdentity) GetDnsLikeIdentity() *TlsIdentity_DnsLikeIdentity {
	if x != nil {
		if x, ok := x.Strategy.(*TlsIdentity_DnsLikeIdentity_); ok {
			return x.DnsLikeIdentity
		}
	}
	return nil
}

func (x *TlsIdentity) GetUriLikeIdentity() *TlsIdentity_UriLikeIdentity {
	if x != nil {
		if x, ok := x.Strategy.(*TlsIdentity_UriLikeIdentity_); ok {
			return x.UriLikeIdentity
		}
	}
	return nil
}

func (x *TlsIdentity) GetServerName() *TlsIdentity_DnsLikeIdentity {
	if x != nil {
		return x.ServerName
	}
	return nil
}

type isTlsIdentity_Strategy interface {
	isTlsIdentity_Strategy()
}

type TlsIdentity_DnsLikeIdentity_ struct {
	DnsLikeIdentity *TlsIdentity_DnsLikeIdentity `protobuf:"bytes,1,opt,name=dns_like_identity,json=dnsLikeIdentity,proto3,oneof"`
}

type TlsIdentity_UriLikeIdentity_ struct {
	UriLikeIdentity *TlsIdentity_UriLikeIdentity `protobuf:"bytes,3,opt,name=uri_like_identity,json=uriLikeIdentity,proto3,oneof"`
}

func (*TlsIdentity_DnsLikeIdentity_) isTlsIdentity_Strategy() {}

func (*TlsIdentity_UriLikeIdentity_) isTlsIdentity_Strategy() {}

type AuthorityOverride struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	AuthorityOverride string                 `protobuf:"bytes,1,opt,name=authority_override,json=authorityOverride,proto3" json:"authority_override,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*AuthorityOverride) ProtoMessage() {}

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

// Deprecated: Use AuthorityOverride.ProtoReflect.Descriptor instead.
func (*AuthorityOverride) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{6}
}

func (x *AuthorityOverride) GetAuthorityOverride() string {
	if x != nil {
		return x.AuthorityOverride
	}
	return ""
}

type NoEndpoints struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Exists        bool                   `protobuf:"varint,1,opt,name=exists,proto3" json:"exists,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NoEndpoints) ProtoMessage() {}

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

// Deprecated: Use NoEndpoints.ProtoReflect.Descriptor instead.
func (*NoEndpoints) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{7}
}

func (x *NoEndpoints) GetExists() bool {
	if x != nil {
		return x.Exists
	}
	return false
}

// A hint of what protocol the service knows. The default value is
// for the `hint` field to be not be set, essentially meaning "unknown".
type ProtocolHint struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Protocol:
	//
	//	*ProtocolHint_H2_
	//	*ProtocolHint_Opaque_
	Protocol isProtocolHint_Protocol `protobuf_oneof:"protocol"`
	// When set, indicates that the target supports receiving opaque traffic
	// wrapped with the Linkerd connection header on the specified port.
	OpaqueTransport *ProtocolHint_OpaqueTransport `protobuf:"bytes,2,opt,name=opaque_transport,json=opaqueTransport,proto3" json:"opaque_transport,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ProtocolHint) ProtoMessage() {}

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

// Deprecated: Use ProtocolHint.ProtoReflect.Descriptor instead.
func (*ProtocolHint) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{8}
}

func (x *ProtocolHint) GetProtocol() isProtocolHint_Protocol {
	if x != nil {
		return x.Protocol
	}
	return nil
}

func (x *ProtocolHint) GetH2() *ProtocolHint_H2 {
	if x != nil {
		if x, ok := x.Protocol.(*ProtocolHint_H2_); ok {
			return x.H2
		}
	}
	return nil
}

func (x *ProtocolHint) GetOpaque() *ProtocolHint_Opaque {
	if x != nil {
		if x, ok := x.Protocol.(*ProtocolHint_Opaque_); ok {
			return x.Opaque
		}
	}
	return nil
}

func (x *ProtocolHint) GetOpaqueTransport() *ProtocolHint_OpaqueTransport {
	if x != nil {
		return x.OpaqueTransport
	}
	return nil
}

type isProtocolHint_Protocol interface {
	isProtocolHint_Protocol()
}

type ProtocolHint_H2_ struct {
	// Hints that the service understands HTTP2 and the proxy's internal
	// http2-upgrade mechanism.
	H2 *ProtocolHint_H2 `protobuf:"bytes,1,opt,name=h2,proto3,oneof"`
}

type ProtocolHint_Opaque_ struct {
	// Hints that the destination will handle this connection as an opaque TCP
	// stream, and (if `opaque_transport` is set) that the proxy should not send
	// a `SessionProtocol` as part of its transport header.
	Opaque *ProtocolHint_Opaque `protobuf:"bytes,3,opt,name=opaque,proto3,oneof"`
}

func (*ProtocolHint_H2_) isProtocolHint_Protocol() {}

func (*ProtocolHint_Opaque_) isProtocolHint_Protocol() {}

// Configures the parameters used to initialize an HTTP/2 connection.
type Http2ClientParams struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Overrides the default client flow control settings.
	FlowControl *Http2ClientParams_FlowControl `protobuf:"bytes,1,opt,name=flow_control,json=flowControl,proto3" json:"flow_control,omitempty"`
	// Enables keep-alive timeouts.
	KeepAlive *Http2ClientParams_KeepAlive `protobuf:"bytes,2,opt,name=keep_alive,json=keepAlive,proto3" json:"keep_alive,omitempty"`
	// Configures Hyper internals.
	Internals     *Http2ClientParams_Internals `protobuf:"bytes,3,opt,name=internals,proto3" json:"internals,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Http2ClientParams) ProtoMessage() {}

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

// Deprecated: Use Http2ClientParams.ProtoReflect.Descriptor instead.
func (*Http2ClientParams) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{9}
}

func (x *Http2ClientParams) GetFlowControl() *Http2ClientParams_FlowControl {
	if x != nil {
		return x.FlowControl
	}
	return nil
}

func (x *Http2ClientParams) GetKeepAlive() *Http2ClientParams_KeepAlive {
	if x != nil {
		return x.KeepAlive
	}
	return nil
}

func (x *Http2ClientParams) GetInternals() *Http2ClientParams_Internals {
	if x != nil {
		return x.Internals
	}
	return nil
}

type DestinationProfile struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The fully-qualified service name, if one exists.
	//
	// When resolving (especially by IP), this field provides the fully-qualified
	// name of the resolved service, if one exists. This field does NOT include
	// any port information. E.g. a lookup for 10.2.3.4:8080 might have a name
	// like `foo.bar.svc.cluster.local`.
	//
	// Implementations MAY provide names for non-service IP-lookups (e.g., pod or
	// node dns names), but this is not required.
	//
	// If the lookup does not refer to a known named entity, this field MUST be
	// left empty.
	FullyQualifiedName string `protobuf:"bytes,5,opt,name=fully_qualified_name,json=fullyQualifiedName,proto3" json:"fully_qualified_name,omitempty"`
	// Indicates that connections on this service address should be handled as
	// opaque TCP streams. HTTP routes returned on for such services will be
	// ignored.
	OpaqueProtocol bool `protobuf:"varint,4,opt,name=opaque_protocol,json=opaqueProtocol,proto3" json:"opaque_protocol,omitempty"`
	// A list of routes, each with a RequestMatch.  If a request matches
	// more than one route, the first match wins.
	Routes []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	// The retry budget controls how much additional load the proxy can generate
	// as retries. Failured requests on retryable routes will not be retried if
	// there is no available budget.
	RetryBudget *RetryBudget `protobuf:"bytes,2,opt,name=retry_budget,json=retryBudget,proto3" json:"retry_budget,omitempty"`
	// If this list is non-empty, requests to this destination should instead be
	// split between the destinations in this list.  Each destination should
	// receive a portion of the requests proportional to its weight.  If this
	// list is empty, requests should be sent to this destination as normal.
	DstOverrides []*WeightedDst `protobuf:"bytes,3,rep,name=dst_overrides,json=dstOverrides,proto3" json:"dst_overrides,omitempty"`
	// If this field is set, it indicates that the target is a known endpoint (and
	// not a service address). The values of `fully_qualified_name` and
	// `dst_overrides` will be ignored for the purposes of service discovery--
	// traffic split and load balancing will be skipped and the single endpoint
	// are used.
	//
	// No endpoint should be set If the target is unknown.
	Endpoint *WeightedAddr `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	// A reference to the metadata for this destination, usually a service. May be
	// omitted if the destination is not a service.
	ParentRef *meta.Metadata `protobuf:"bytes,7,opt,name=parent_ref,json=parentRef,proto3" json:"parent_ref,omitempty"`
	// A reference to the metadata for a ServiceProfile resource. This is omitted
	// when no ServiceProfile resource exists.
	ProfileRef    *meta.Metadata `protobuf:"bytes,8,opt,name=profile_ref,json=profileRef,proto3" json:"profile_ref,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DestinationProfile) ProtoMessage() {}

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

// Deprecated: Use DestinationProfile.ProtoReflect.Descriptor instead.
func (*DestinationProfile) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{10}
}

func (x *DestinationProfile) GetFullyQualifiedName() string {
	if x != nil {
		return x.FullyQualifiedName
	}
	return ""
}

func (x *DestinationProfile) GetOpaqueProtocol() bool {
	if x != nil {
		return x.OpaqueProtocol
	}
	return false
}

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

func (x *DestinationProfile) GetRetryBudget() *RetryBudget {
	if x != nil {
		return x.RetryBudget
	}
	return nil
}

func (x *DestinationProfile) GetDstOverrides() []*WeightedDst {
	if x != nil {
		return x.DstOverrides
	}
	return nil
}

func (x *DestinationProfile) GetEndpoint() *WeightedAddr {
	if x != nil {
		return x.Endpoint
	}
	return nil
}

func (x *DestinationProfile) GetParentRef() *meta.Metadata {
	if x != nil {
		return x.ParentRef
	}
	return nil
}

func (x *DestinationProfile) GetProfileRef() *meta.Metadata {
	if x != nil {
		return x.ProfileRef
	}
	return nil
}

type Route struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This route contains requests which match this condition.
	Condition *RequestMatch `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	// A list of response classes for this route.  If a response matches
	// more than one ResponseClass, the first match wins.  If a response does not
	// match any ResponseClasses, it is considered to be a successful response.
	ResponseClasses []*ResponseClass `protobuf:"bytes,2,rep,name=response_classes,json=responseClasses,proto3" json:"response_classes,omitempty"`
	// Metric labels to attach to requests and responses that match this route.
	MetricsLabels map[string]string `protobuf:"bytes,3,rep,name=metrics_labels,json=metricsLabels,proto3" json:"metrics_labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// If a route is retryable, any failed requests on that route may be retried
	// by the proxy.
	IsRetryable bool `protobuf:"varint,4,opt,name=is_retryable,json=isRetryable,proto3" json:"is_retryable,omitempty"`
	// After this time has elapsed since receiving the initial request, any
	// outstanding request will be cancelled, a timeout error response will be
	// returned, and no more retries will be attempted.
	Timeout       *duration.Duration `protobuf:"bytes,5,opt,name=timeout,proto3" json:"timeout,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Route) ProtoMessage() {}

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

// Deprecated: Use Route.ProtoReflect.Descriptor instead.
func (*Route) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{11}
}

func (x *Route) GetCondition() *RequestMatch {
	if x != nil {
		return x.Condition
	}
	return nil
}

func (x *Route) GetResponseClasses() []*ResponseClass {
	if x != nil {
		return x.ResponseClasses
	}
	return nil
}

func (x *Route) GetMetricsLabels() map[string]string {
	if x != nil {
		return x.MetricsLabels
	}
	return nil
}

func (x *Route) GetIsRetryable() bool {
	if x != nil {
		return x.IsRetryable
	}
	return false
}

func (x *Route) GetTimeout() *duration.Duration {
	if x != nil {
		return x.Timeout
	}
	return nil
}

type RetryBudget struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ratio of additional traffic that may be added by retries.  A
	// retry_ratio of 0.1 means that 1 retry may be attempted for every 10 regular
	// requests.  A retry_ratio of 1.0 means that 1 retry may be attempted for
	// every 1 regular request (in other words, total request load may be doubled
	// as a result of retries).
	RetryRatio float32 `protobuf:"fixed32,1,opt,name=retry_ratio,json=retryRatio,proto3" json:"retry_ratio,omitempty"`
	// The proxy may always attempt this number of retries per second, even if it
	// would violate the retry_ratio.  This is to allow retries to happen even
	// when the request rate is very low.
	MinRetriesPerSecond uint32 `protobuf:"varint,2,opt,name=min_retries_per_second,json=minRetriesPerSecond,proto3" json:"min_retries_per_second,omitempty"`
	// This duration indicates for how long requests should be considered for the
	// purposes of enforcing the retry_ratio.  A higher value considers a larger
	// window and therefore allows burstier retries.
	Ttl           *duration.Duration `protobuf:"bytes,3,opt,name=ttl,proto3" json:"ttl,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RetryBudget) ProtoMessage() {}

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

// Deprecated: Use RetryBudget.ProtoReflect.Descriptor instead.
func (*RetryBudget) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{12}
}

func (x *RetryBudget) GetRetryRatio() float32 {
	if x != nil {
		return x.RetryRatio
	}
	return 0
}

func (x *RetryBudget) GetMinRetriesPerSecond() uint32 {
	if x != nil {
		return x.MinRetriesPerSecond
	}
	return 0
}

func (x *RetryBudget) GetTtl() *duration.Duration {
	if x != nil {
		return x.Ttl
	}
	return nil
}

type ResponseClass struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This class contains responses which match this condition.
	Condition *ResponseMatch `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	// If responses in this class should be considered failures.  This defaults
	// to false (success).
	IsFailure     bool `protobuf:"varint,2,opt,name=is_failure,json=isFailure,proto3" json:"is_failure,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ResponseClass) ProtoMessage() {}

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

// Deprecated: Use ResponseClass.ProtoReflect.Descriptor instead.
func (*ResponseClass) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{13}
}

func (x *ResponseClass) GetCondition() *ResponseMatch {
	if x != nil {
		return x.Condition
	}
	return nil
}

func (x *ResponseClass) GetIsFailure() bool {
	if x != nil {
		return x.IsFailure
	}
	return false
}

type RequestMatch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Match:
	//
	//	*RequestMatch_All
	//	*RequestMatch_Any
	//	*RequestMatch_Not
	//	*RequestMatch_Path
	//	*RequestMatch_Method
	Match         isRequestMatch_Match `protobuf_oneof:"match"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RequestMatch) ProtoMessage() {}

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

// Deprecated: Use RequestMatch.ProtoReflect.Descriptor instead.
func (*RequestMatch) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{14}
}

func (x *RequestMatch) GetMatch() isRequestMatch_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *RequestMatch) GetAll() *RequestMatch_Seq {
	if x != nil {
		if x, ok := x.Match.(*RequestMatch_All); ok {
			return x.All
		}
	}
	return nil
}

func (x *RequestMatch) GetAny() *RequestMatch_Seq {
	if x != nil {
		if x, ok := x.Match.(*RequestMatch_Any); ok {
			return x.Any
		}
	}
	return nil
}

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

func (x *RequestMatch) GetPath() *PathMatch {
	if x != nil {
		if x, ok := x.Match.(*RequestMatch_Path); ok {
			return x.Path
		}
	}
	return nil
}

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

type isRequestMatch_Match interface {
	isRequestMatch_Match()
}

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

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

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

type RequestMatch_Path struct {
	Path *PathMatch `protobuf:"bytes,4,opt,name=path,proto3,oneof"`
}

type RequestMatch_Method struct {
	Method *http_types.HttpMethod `protobuf:"bytes,5,opt,name=method,proto3,oneof"` // TODO: match on arbitrary header
}

func (*RequestMatch_All) isRequestMatch_Match() {}

func (*RequestMatch_Any) isRequestMatch_Match() {}

func (*RequestMatch_Not) isRequestMatch_Match() {}

func (*RequestMatch_Path) isRequestMatch_Match() {}

func (*RequestMatch_Method) isRequestMatch_Match() {}

type PathMatch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Match if the request path matches this regex.
	Regex         string `protobuf:"bytes,1,opt,name=regex,proto3" json:"regex,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PathMatch) ProtoMessage() {}

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

// Deprecated: Use PathMatch.ProtoReflect.Descriptor instead.
func (*PathMatch) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{15}
}

func (x *PathMatch) GetRegex() string {
	if x != nil {
		return x.Regex
	}
	return ""
}

type ResponseMatch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Match:
	//
	//	*ResponseMatch_All
	//	*ResponseMatch_Any
	//	*ResponseMatch_Not
	//	*ResponseMatch_Status
	Match         isResponseMatch_Match `protobuf_oneof:"match"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ResponseMatch) ProtoMessage() {}

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

// Deprecated: Use ResponseMatch.ProtoReflect.Descriptor instead.
func (*ResponseMatch) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{16}
}

func (x *ResponseMatch) GetMatch() isResponseMatch_Match {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *ResponseMatch) GetAll() *ResponseMatch_Seq {
	if x != nil {
		if x, ok := x.Match.(*ResponseMatch_All); ok {
			return x.All
		}
	}
	return nil
}

func (x *ResponseMatch) GetAny() *ResponseMatch_Seq {
	if x != nil {
		if x, ok := x.Match.(*ResponseMatch_Any); ok {
			return x.Any
		}
	}
	return nil
}

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

func (x *ResponseMatch) GetStatus() *HttpStatusRange {
	if x != nil {
		if x, ok := x.Match.(*ResponseMatch_Status); ok {
			return x.Status
		}
	}
	return nil
}

type isResponseMatch_Match interface {
	isResponseMatch_Match()
}

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

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

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

type ResponseMatch_Status struct {
	Status *HttpStatusRange `protobuf:"bytes,4,opt,name=status,proto3,oneof"` // TODO: match on arbitrary header or trailer
}

func (*ResponseMatch_All) isResponseMatch_Match() {}

func (*ResponseMatch_Any) isResponseMatch_Match() {}

func (*ResponseMatch_Not) isResponseMatch_Match() {}

func (*ResponseMatch_Status) isResponseMatch_Match() {}

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

func (x *HttpStatusRange) Reset() {
	*x = HttpStatusRange{}
	mi := &file_destination_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*HttpStatusRange) ProtoMessage() {}

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

// Deprecated: Use HttpStatusRange.ProtoReflect.Descriptor instead.
func (*HttpStatusRange) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{17}
}

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

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

type WeightedDst struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This authority will be used as the `path` in a call to the Destination.Get
	// rpc.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// The proportion of requests to send to this destination.  This value is
	// relative to other weights in the same dst_overrides list.
	Weight uint32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
	// A reference to the metadata for a Service resource.
	BackendRef    *meta.Metadata `protobuf:"bytes,3,opt,name=backend_ref,json=backendRef,proto3" json:"backend_ref,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WeightedDst) Reset() {
	*x = WeightedDst{}
	mi := &file_destination_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*WeightedDst) ProtoMessage() {}

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

// Deprecated: Use WeightedDst.ProtoReflect.Descriptor instead.
func (*WeightedDst) Descriptor() ([]byte, []int) {
	return file_destination_proto_rawDescGZIP(), []int{18}
}

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

func (x *WeightedDst) GetWeight() uint32 {
	if x != nil {
		return x.Weight
	}
	return 0
}

func (x *WeightedDst) GetBackendRef() *meta.Metadata {
	if x != nil {
		return x.BackendRef
	}
	return nil
}

// Verify the certificate based on the Kubernetes pod identity.
type TlsIdentity_DnsLikeIdentity struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A DNS-like name that encodes workload coordinates.
	//
	// For example:
	//
	//	{name}.{namespace}.{type}.identity.{control-namespace}.{trust-domain...}
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TlsIdentity_DnsLikeIdentity) ProtoMessage() {}

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

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

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

// Verify the certificate based on an URI identity.
type TlsIdentity_UriLikeIdentity struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A URI name that encodes workload identity.
	//
	// For example:
	//
	//	spiffe://trust-domain/workload-dentifier
	Uri           string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TlsIdentity_UriLikeIdentity) ProtoMessage() {}

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

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

func (x *TlsIdentity_UriLikeIdentity) GetUri() string {
	if x != nil {
		return x.Uri
	}
	return ""
}

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

func (x *ProtocolHint_H2) Reset() {
	*x = ProtocolHint_H2{}
	mi := &file_destination_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProtocolHint_H2) ProtoMessage() {}

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

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

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

func (x *ProtocolHint_Opaque) Reset() {
	*x = ProtocolHint_Opaque{}
	mi := &file_destination_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProtocolHint_Opaque) ProtoMessage() {}

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

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

type ProtocolHint_OpaqueTransport struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The target proxy's inbound port.
	InboundPort   uint32 `protobuf:"varint,1,opt,name=inbound_port,json=inboundPort,proto3" json:"inbound_port,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProtocolHint_OpaqueTransport) Reset() {
	*x = ProtocolHint_OpaqueTransport{}
	mi := &file_destination_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProtocolHint_OpaqueTransport) ProtoMessage() {}

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

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

func (x *ProtocolHint_OpaqueTransport) GetInboundPort() uint32 {
	if x != nil {
		return x.InboundPort
	}
	return 0
}

type Http2ClientParams_FlowControl struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configures the maximum connection-level flow control window size.
	InitialConnectionWindowSize uint32 `protobuf:"varint,1,opt,name=initial_connection_window_size,json=initialConnectionWindowSize,proto3" json:"initial_connection_window_size,omitempty"`
	// Configures the maximum stream-level flow control window size.
	InitialStreamWindowSize uint32 `protobuf:"varint,2,opt,name=initial_stream_window_size,json=initialStreamWindowSize,proto3" json:"initial_stream_window_size,omitempty"`
	// Enables Hyper's adaptive flow control, ignoring other window settings.
	AdaptiveFlowControl bool `protobuf:"varint,3,opt,name=adaptive_flow_control,json=adaptiveFlowControl,proto3" json:"adaptive_flow_control,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *Http2ClientParams_FlowControl) Reset() {
	*x = Http2ClientParams_FlowControl{}
	mi := &file_destination_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Http2ClientParams_FlowControl) ProtoMessage() {}

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

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

func (x *Http2ClientParams_FlowControl) GetInitialConnectionWindowSize() uint32 {
	if x != nil {
		return x.InitialConnectionWindowSize
	}
	return 0
}

func (x *Http2ClientParams_FlowControl) GetInitialStreamWindowSize() uint32 {
	if x != nil {
		return x.InitialStreamWindowSize
	}
	return 0
}

func (x *Http2ClientParams_FlowControl) GetAdaptiveFlowControl() bool {
	if x != nil {
		return x.AdaptiveFlowControl
	}
	return false
}

type Http2ClientParams_KeepAlive struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The time between pings.
	Interval *duration.Duration `protobuf:"bytes,1,opt,name=interval,proto3" json:"interval,omitempty"`
	// The time to wait for a ping response before considering the connection
	// dead.
	Timeout *duration.Duration `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// Whether to send pings when there is no other traffic.
	WhileIdle     bool `protobuf:"varint,3,opt,name=while_idle,json=whileIdle,proto3" json:"while_idle,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Http2ClientParams_KeepAlive) Reset() {
	*x = Http2ClientParams_KeepAlive{}
	mi := &file_destination_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Http2ClientParams_KeepAlive) ProtoMessage() {}

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

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

func (x *Http2ClientParams_KeepAlive) GetInterval() *duration.Duration {
	if x != nil {
		return x.Interval
	}
	return nil
}

func (x *Http2ClientParams_KeepAlive) GetTimeout() *duration.Duration {
	if x != nil {
		return x.Timeout
	}
	return nil
}

func (x *Http2ClientParams_KeepAlive) GetWhileIdle() bool {
	if x != nil {
		return x.WhileIdle
	}
	return false
}

type Http2ClientParams_Internals struct {
	state                     protoimpl.MessageState `protogen:"open.v1"`
	MaxConcurrentResetStreams uint32                 `protobuf:"varint,1,opt,name=max_concurrent_reset_streams,json=maxConcurrentResetStreams,proto3" json:"max_concurrent_reset_streams,omitempty"`
	MaxFrameSize              uint32                 `protobuf:"varint,2,opt,name=max_frame_size,json=maxFrameSize,proto3" json:"max_frame_size,omitempty"`
	MaxSendBufSize            uint32                 `protobuf:"varint,3,opt,name=max_send_buf_size,json=maxSendBufSize,proto3" json:"max_send_buf_size,omitempty"`
	unknownFields             protoimpl.UnknownFields
	sizeCache                 protoimpl.SizeCache
}

func (x *Http2ClientParams_Internals) Reset() {
	*x = Http2ClientParams_Internals{}
	mi := &file_destination_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Http2ClientParams_Internals) ProtoMessage() {}

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

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

func (x *Http2ClientParams_Internals) GetMaxConcurrentResetStreams() uint32 {
	if x != nil {
		return x.MaxConcurrentResetStreams
	}
	return 0
}

func (x *Http2ClientParams_Internals) GetMaxFrameSize() uint32 {
	if x != nil {
		return x.MaxFrameSize
	}
	return 0
}

func (x *Http2ClientParams_Internals) GetMaxSendBufSize() uint32 {
	if x != nil {
		return x.MaxSendBufSize
	}
	return 0
}

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

func (x *RequestMatch_Seq) Reset() {
	*x = RequestMatch_Seq{}
	mi := &file_destination_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RequestMatch_Seq) ProtoMessage() {}

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

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

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

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

func (x *ResponseMatch_Seq) Reset() {
	*x = ResponseMatch_Seq{}
	mi := &file_destination_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ResponseMatch_Seq) ProtoMessage() {}

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

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

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

var File_destination_proto protoreflect.FileDescriptor

const file_destination_proto_rawDesc = "" +
	"\n" +
	"\x11destination.proto\x12\x1cio.linkerd.proxy.destination\x1a\x1egoogle/protobuf/duration.proto\x1a\x10http_types.proto\x1a\n" +
	"meta.proto\x1a\tnet.proto\"a\n" +
	"\x0eGetDestination\x12\x16\n" +
	"\x06scheme\x18\x01 \x01(\tR\x06scheme\x12\x12\n" +
	"\x04path\x18\x02 \x01(\tR\x04path\x12#\n" +
	"\rcontext_token\x18\x03 \x01(\tR\fcontextToken\"\xe6\x01\n" +
	"\x06Update\x12A\n" +
	"\x03add\x18\x01 \x01(\v2-.io.linkerd.proxy.destination.WeightedAddrSetH\x00R\x03add\x12?\n" +
	"\x06remove\x18\x02 \x01(\v2%.io.linkerd.proxy.destination.AddrSetH\x00R\x06remove\x12N\n" +
	"\fno_endpoints\x18\x03 \x01(\v2).io.linkerd.proxy.destination.NoEndpointsH\x00R\vnoEndpointsB\b\n" +
	"\x06update\"A\n" +
	"\aAddrSet\x126\n" +
	"\x05addrs\x18\x01 \x03(\v2 .io.linkerd.proxy.net.TcpAddressR\x05addrs\"\xfa\x01\n" +
	"\x0fWeightedAddrSet\x12@\n" +
	"\x05addrs\x18\x01 \x03(\v2*.io.linkerd.proxy.destination.WeightedAddrR\x05addrs\x12d\n" +
	"\rmetric_labels\x18\x02 \x03(\v2?.io.linkerd.proxy.destination.WeightedAddrSet.MetricLabelsEntryR\fmetricLabels\x1a?\n" +
	"\x11MetricLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x8a\x05\n" +
	"\fWeightedAddr\x124\n" +
	"\x04addr\x18\x01 \x01(\v2 .io.linkerd.proxy.net.TcpAddressR\x04addr\x12\x16\n" +
	"\x06weight\x18\x03 \x01(\rR\x06weight\x12a\n" +
	"\rmetric_labels\x18\x04 \x03(\v2<.io.linkerd.proxy.destination.WeightedAddr.MetricLabelsEntryR\fmetricLabels\x12L\n" +
	"\ftls_identity\x18\x05 \x01(\v2).io.linkerd.proxy.destination.TlsIdentityR\vtlsIdentity\x12O\n" +
	"\rprotocol_hint\x18\x06 \x01(\v2*.io.linkerd.proxy.destination.ProtocolHintR\fprotocolHint\x12^\n" +
	"\x12authority_override\x18\a \x01(\v2/.io.linkerd.proxy.destination.AuthorityOverrideR\x11authorityOverride\x12E\n" +
	"\x05http2\x18\b \x01(\v2/.io.linkerd.proxy.destination.Http2ClientParamsR\x05http2\x12B\n" +
	"\fresource_ref\x18\t \x01(\v2\x1f.io.linkerd.proxy.meta.MetadataR\vresourceRef\x1a?\n" +
	"\x11MetricLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xab\x03\n" +
	"\vTlsIdentity\x12g\n" +
	"\x11dns_like_identity\x18\x01 \x01(\v29.io.linkerd.proxy.destination.TlsIdentity.DnsLikeIdentityH\x00R\x0fdnsLikeIdentity\x12g\n" +
	"\x11uri_like_identity\x18\x03 \x01(\v29.io.linkerd.proxy.destination.TlsIdentity.UriLikeIdentityH\x00R\x0furiLikeIdentity\x12Z\n" +
	"\vserver_name\x18\x04 \x01(\v29.io.linkerd.proxy.destination.TlsIdentity.DnsLikeIdentityR\n" +
	"serverName\x1a%\n" +
	"\x0fDnsLikeIdentity\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x1a#\n" +
	"\x0fUriLikeIdentity\x12\x10\n" +
	"\x03uri\x18\x01 \x01(\tR\x03uriB\n" +
	"\n" +
	"\bstrategyJ\x04\b\x02\x10\x03R\x10k8s_pod_identity\"B\n" +
	"\x11AuthorityOverride\x12-\n" +
	"\x12authority_override\x18\x01 \x01(\tR\x11authorityOverride\"%\n" +
	"\vNoEndpoints\x12\x16\n" +
	"\x06exists\x18\x01 \x01(\bR\x06exists\"\xd5\x02\n" +
	"\fProtocolHint\x12?\n" +
	"\x02h2\x18\x01 \x01(\v2-.io.linkerd.proxy.destination.ProtocolHint.H2H\x00R\x02h2\x12K\n" +
	"\x06opaque\x18\x03 \x01(\v21.io.linkerd.proxy.destination.ProtocolHint.OpaqueH\x00R\x06opaque\x12e\n" +
	"\x10opaque_transport\x18\x02 \x01(\v2:.io.linkerd.proxy.destination.ProtocolHint.OpaqueTransportR\x0fopaqueTransport\x1a\x04\n" +
	"\x02H2\x1a\b\n" +
	"\x06Opaque\x1a4\n" +
	"\x0fOpaqueTransport\x12!\n" +
	"\finbound_port\x18\x01 \x01(\rR\vinboundPortB\n" +
	"\n" +
	"\bprotocol\"\xa5\x06\n" +
	"\x11Http2ClientParams\x12^\n" +
	"\fflow_control\x18\x01 \x01(\v2;.io.linkerd.proxy.destination.Http2ClientParams.FlowControlR\vflowControl\x12X\n" +
	"\n" +
	"keep_alive\x18\x02 \x01(\v29.io.linkerd.proxy.destination.Http2ClientParams.KeepAliveR\tkeepAlive\x12W\n" +
	"\tinternals\x18\x03 \x01(\v29.io.linkerd.proxy.destination.Http2ClientParams.InternalsR\tinternals\x1a\xc3\x01\n" +
	"\vFlowControl\x12C\n" +
	"\x1einitial_connection_window_size\x18\x01 \x01(\rR\x1binitialConnectionWindowSize\x12;\n" +
	"\x1ainitial_stream_window_size\x18\x02 \x01(\rR\x17initialStreamWindowSize\x122\n" +
	"\x15adaptive_flow_control\x18\x03 \x01(\bR\x13adaptiveFlowControl\x1a\x96\x01\n" +
	"\tKeepAlive\x125\n" +
	"\binterval\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\binterval\x123\n" +
	"\atimeout\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\atimeout\x12\x1d\n" +
	"\n" +
	"while_idle\x18\x03 \x01(\bR\twhileIdle\x1a\x9d\x01\n" +
	"\tInternals\x12?\n" +
	"\x1cmax_concurrent_reset_streams\x18\x01 \x01(\rR\x19maxConcurrentResetStreams\x12$\n" +
	"\x0emax_frame_size\x18\x02 \x01(\rR\fmaxFrameSize\x12)\n" +
	"\x11max_send_buf_size\x18\x03 \x01(\rR\x0emaxSendBufSize\"\x94\x04\n" +
	"\x12DestinationProfile\x120\n" +
	"\x14fully_qualified_name\x18\x05 \x01(\tR\x12fullyQualifiedName\x12'\n" +
	"\x0fopaque_protocol\x18\x04 \x01(\bR\x0eopaqueProtocol\x12;\n" +
	"\x06routes\x18\x01 \x03(\v2#.io.linkerd.proxy.destination.RouteR\x06routes\x12L\n" +
	"\fretry_budget\x18\x02 \x01(\v2).io.linkerd.proxy.destination.RetryBudgetR\vretryBudget\x12N\n" +
	"\rdst_overrides\x18\x03 \x03(\v2).io.linkerd.proxy.destination.WeightedDstR\fdstOverrides\x12F\n" +
	"\bendpoint\x18\x06 \x01(\v2*.io.linkerd.proxy.destination.WeightedAddrR\bendpoint\x12>\n" +
	"\n" +
	"parent_ref\x18\a \x01(\v2\x1f.io.linkerd.proxy.meta.MetadataR\tparentRef\x12@\n" +
	"\vprofile_ref\x18\b \x01(\v2\x1f.io.linkerd.proxy.meta.MetadataR\n" +
	"profileRef\"\xa2\x03\n" +
	"\x05Route\x12H\n" +
	"\tcondition\x18\x01 \x01(\v2*.io.linkerd.proxy.destination.RequestMatchR\tcondition\x12V\n" +
	"\x10response_classes\x18\x02 \x03(\v2+.io.linkerd.proxy.destination.ResponseClassR\x0fresponseClasses\x12]\n" +
	"\x0emetrics_labels\x18\x03 \x03(\v26.io.linkerd.proxy.destination.Route.MetricsLabelsEntryR\rmetricsLabels\x12!\n" +
	"\fis_retryable\x18\x04 \x01(\bR\visRetryable\x123\n" +
	"\atimeout\x18\x05 \x01(\v2\x19.google.protobuf.DurationR\atimeout\x1a@\n" +
	"\x12MetricsLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x90\x01\n" +
	"\vRetryBudget\x12\x1f\n" +
	"\vretry_ratio\x18\x01 \x01(\x02R\n" +
	"retryRatio\x123\n" +
	"\x16min_retries_per_second\x18\x02 \x01(\rR\x13minRetriesPerSecond\x12+\n" +
	"\x03ttl\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\x03ttl\"y\n" +
	"\rResponseClass\x12I\n" +
	"\tcondition\x18\x01 \x01(\v2+.io.linkerd.proxy.destination.ResponseMatchR\tcondition\x12\x1d\n" +
	"\n" +
	"is_failure\x18\x02 \x01(\bR\tisFailure\"\xae\x03\n" +
	"\fRequestMatch\x12B\n" +
	"\x03all\x18\x01 \x01(\v2..io.linkerd.proxy.destination.RequestMatch.SeqH\x00R\x03all\x12B\n" +
	"\x03any\x18\x02 \x01(\v2..io.linkerd.proxy.destination.RequestMatch.SeqH\x00R\x03any\x12>\n" +
	"\x03not\x18\x03 \x01(\v2*.io.linkerd.proxy.destination.RequestMatchH\x00R\x03not\x12=\n" +
	"\x04path\x18\x04 \x01(\v2'.io.linkerd.proxy.destination.PathMatchH\x00R\x04path\x12A\n" +
	"\x06method\x18\x05 \x01(\v2'.io.linkerd.proxy.http_types.HttpMethodH\x00R\x06method\x1aK\n" +
	"\x03Seq\x12D\n" +
	"\amatches\x18\x01 \x03(\v2*.io.linkerd.proxy.destination.RequestMatchR\amatchesB\a\n" +
	"\x05match\"!\n" +
	"\tPathMatch\x12\x14\n" +
	"\x05regex\x18\x01 \x01(\tR\x05regex\"\xfa\x02\n" +
	"\rResponseMatch\x12C\n" +
	"\x03all\x18\x01 \x01(\v2/.io.linkerd.proxy.destination.ResponseMatch.SeqH\x00R\x03all\x12C\n" +
	"\x03any\x18\x02 \x01(\v2/.io.linkerd.proxy.destination.ResponseMatch.SeqH\x00R\x03any\x12?\n" +
	"\x03not\x18\x03 \x01(\v2+.io.linkerd.proxy.destination.ResponseMatchH\x00R\x03not\x12G\n" +
	"\x06status\x18\x04 \x01(\v2-.io.linkerd.proxy.destination.HttpStatusRangeH\x00R\x06status\x1aL\n" +
	"\x03Seq\x12E\n" +
	"\amatches\x18\x01 \x03(\v2+.io.linkerd.proxy.destination.ResponseMatchR\amatchesB\a\n" +
	"\x05match\"5\n" +
	"\x0fHttpStatusRange\x12\x10\n" +
	"\x03min\x18\x01 \x01(\rR\x03min\x12\x10\n" +
	"\x03max\x18\x02 \x01(\rR\x03max\"\x85\x01\n" +
	"\vWeightedDst\x12\x1c\n" +
	"\tauthority\x18\x01 \x01(\tR\tauthority\x12\x16\n" +
	"\x06weight\x18\x02 \x01(\rR\x06weight\x12@\n" +
	"\vbackend_ref\x18\x03 \x01(\v2\x1f.io.linkerd.proxy.meta.MetadataR\n" +
	"backendRef2\xde\x01\n" +
	"\vDestination\x12]\n" +
	"\x03Get\x12,.io.linkerd.proxy.destination.GetDestination\x1a$.io.linkerd.proxy.destination.Update\"\x000\x01\x12p\n" +
	"\n" +
	"GetProfile\x12,.io.linkerd.proxy.destination.GetDestination\x1a0.io.linkerd.proxy.destination.DestinationProfile\"\x000\x01B6Z4github.com/linkerd/linkerd2-proxy-api/go/destinationb\x06proto3"

var (
	file_destination_proto_rawDescOnce sync.Once
	file_destination_proto_rawDescData []byte
)

func file_destination_proto_rawDescGZIP() []byte {
	file_destination_proto_rawDescOnce.Do(func() {
		file_destination_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_destination_proto_rawDesc), len(file_destination_proto_rawDesc)))
	})
	return file_destination_proto_rawDescData
}

var file_destination_proto_msgTypes = make([]protoimpl.MessageInfo, 32)
var file_destination_proto_goTypes = []any{
	(*GetDestination)(nil),                // 0: io.linkerd.proxy.destination.GetDestination
	(*Update)(nil),                        // 1: io.linkerd.proxy.destination.Update
	(*AddrSet)(nil),                       // 2: io.linkerd.proxy.destination.AddrSet
	(*WeightedAddrSet)(nil),               // 3: io.linkerd.proxy.destination.WeightedAddrSet
	(*WeightedAddr)(nil),                  // 4: io.linkerd.proxy.destination.WeightedAddr
	(*TlsIdentity)(nil),                   // 5: io.linkerd.proxy.destination.TlsIdentity
	(*AuthorityOverride)(nil),             // 6: io.linkerd.proxy.destination.AuthorityOverride
	(*NoEndpoints)(nil),                   // 7: io.linkerd.proxy.destination.NoEndpoints
	(*ProtocolHint)(nil),                  // 8: io.linkerd.proxy.destination.ProtocolHint
	(*Http2ClientParams)(nil),             // 9: io.linkerd.proxy.destination.Http2ClientParams
	(*DestinationProfile)(nil),            // 10: io.linkerd.proxy.destination.DestinationProfile
	(*Route)(nil),                         // 11: io.linkerd.proxy.destination.Route
	(*RetryBudget)(nil),                   // 12: io.linkerd.proxy.destination.RetryBudget
	(*ResponseClass)(nil),                 // 13: io.linkerd.proxy.destination.ResponseClass
	(*RequestMatch)(nil),                  // 14: io.linkerd.proxy.destination.RequestMatch
	(*PathMatch)(nil),                     // 15: io.linkerd.proxy.destination.PathMatch
	(*ResponseMatch)(nil),                 // 16: io.linkerd.proxy.destination.ResponseMatch
	(*HttpStatusRange)(nil),               // 17: io.linkerd.proxy.destination.HttpStatusRange
	(*WeightedDst)(nil),                   // 18: io.linkerd.proxy.destination.WeightedDst
	nil,                                   // 19: io.linkerd.proxy.destination.WeightedAddrSet.MetricLabelsEntry
	nil,                                   // 20: io.linkerd.proxy.destination.WeightedAddr.MetricLabelsEntry
	(*TlsIdentity_DnsLikeIdentity)(nil),   // 21: io.linkerd.proxy.destination.TlsIdentity.DnsLikeIdentity
	(*TlsIdentity_UriLikeIdentity)(nil),   // 22: io.linkerd.proxy.destination.TlsIdentity.UriLikeIdentity
	(*ProtocolHint_H2)(nil),               // 23: io.linkerd.proxy.destination.ProtocolHint.H2
	(*ProtocolHint_Opaque)(nil),           // 24: io.linkerd.proxy.destination.ProtocolHint.Opaque
	(*ProtocolHint_OpaqueTransport)(nil),  // 25: io.linkerd.proxy.destination.ProtocolHint.OpaqueTransport
	(*Http2ClientParams_FlowControl)(nil), // 26: io.linkerd.proxy.destination.Http2ClientParams.FlowControl
	(*Http2ClientParams_KeepAlive)(nil),   // 27: io.linkerd.proxy.destination.Http2ClientParams.KeepAlive
	(*Http2ClientParams_Internals)(nil),   // 28: io.linkerd.proxy.destination.Http2ClientParams.Internals
	nil,                                   // 29: io.linkerd.proxy.destination.Route.MetricsLabelsEntry
	(*RequestMatch_Seq)(nil),              // 30: io.linkerd.proxy.destination.RequestMatch.Seq
	(*ResponseMatch_Seq)(nil),             // 31: io.linkerd.proxy.destination.ResponseMatch.Seq
	(*net.TcpAddress)(nil),                // 32: io.linkerd.proxy.net.TcpAddress
	(*meta.Metadata)(nil),                 // 33: io.linkerd.proxy.meta.Metadata
	(*duration.Duration)(nil),             // 34: google.protobuf.Duration
	(*http_types.HttpMethod)(nil),         // 35: io.linkerd.proxy.http_types.HttpMethod
}
var file_destination_proto_depIdxs = []int32{
	3,  // 0: io.linkerd.proxy.destination.Update.add:type_name -> io.linkerd.proxy.destination.WeightedAddrSet
	2,  // 1: io.linkerd.proxy.destination.Update.remove:type_name -> io.linkerd.proxy.destination.AddrSet
	7,  // 2: io.linkerd.proxy.destination.Update.no_endpoints:type_name -> io.linkerd.proxy.destination.NoEndpoints
	32, // 3: io.linkerd.proxy.destination.AddrSet.addrs:type_name -> io.linkerd.proxy.net.TcpAddress
	4,  // 4: io.linkerd.proxy.destination.WeightedAddrSet.addrs:type_name -> io.linkerd.proxy.destination.WeightedAddr
	19, // 5: io.linkerd.proxy.destination.WeightedAddrSet.metric_labels:type_name -> io.linkerd.proxy.destination.WeightedAddrSet.MetricLabelsEntry
	32, // 6: io.linkerd.proxy.destination.WeightedAddr.addr:type_name -> io.linkerd.proxy.net.TcpAddress
	20, // 7: io.linkerd.proxy.destination.WeightedAddr.metric_labels:type_name -> io.linkerd.proxy.destination.WeightedAddr.MetricLabelsEntry
	5,  // 8: io.linkerd.proxy.destination.WeightedAddr.tls_identity:type_name -> io.linkerd.proxy.destination.TlsIdentity
	8,  // 9: io.linkerd.proxy.destination.WeightedAddr.protocol_hint:type_name -> io.linkerd.proxy.destination.ProtocolHint
	6,  // 10: io.linkerd.proxy.destination.WeightedAddr.authority_override:type_name -> io.linkerd.proxy.destination.AuthorityOverride
	9,  // 11: io.linkerd.proxy.destination.WeightedAddr.http2:type_name -> io.linkerd.proxy.destination.Http2ClientParams
	33, // 12: io.linkerd.proxy.destination.WeightedAddr.resource_ref:type_name -> io.linkerd.proxy.meta.Metadata
	21, // 13: io.linkerd.proxy.destination.TlsIdentity.dns_like_identity:type_name -> io.linkerd.proxy.destination.TlsIdentity.DnsLikeIdentity
	22, // 14: io.linkerd.proxy.destination.TlsIdentity.uri_like_identity:type_name -> io.linkerd.proxy.destination.TlsIdentity.UriLikeIdentity
	21, // 15: io.linkerd.proxy.destination.TlsIdentity.server_name:type_name -> io.linkerd.proxy.destination.TlsIdentity.DnsLikeIdentity
	23, // 16: io.linkerd.proxy.destination.ProtocolHint.h2:type_name -> io.linkerd.proxy.destination.ProtocolHint.H2
	24, // 17: io.linkerd.proxy.destination.ProtocolHint.opaque:type_name -> io.linkerd.proxy.destination.ProtocolHint.Opaque
	25, // 18: io.linkerd.proxy.destination.ProtocolHint.opaque_transport:type_name -> io.linkerd.proxy.destination.ProtocolHint.OpaqueTransport
	26, // 19: io.linkerd.proxy.destination.Http2ClientParams.flow_control:type_name -> io.linkerd.proxy.destination.Http2ClientParams.FlowControl
	27, // 20: io.linkerd.proxy.destination.Http2ClientParams.keep_alive:type_name -> io.linkerd.proxy.destination.Http2ClientParams.KeepAlive
	28, // 21: io.linkerd.proxy.destination.Http2ClientParams.internals:type_name -> io.linkerd.proxy.destination.Http2ClientParams.Internals
	11, // 22: io.linkerd.proxy.destination.DestinationProfile.routes:type_name -> io.linkerd.proxy.destination.Route
	12, // 23: io.linkerd.proxy.destination.DestinationProfile.retry_budget:type_name -> io.linkerd.proxy.destination.RetryBudget
	18, // 24: io.linkerd.proxy.destination.DestinationProfile.dst_overrides:type_name -> io.linkerd.proxy.destination.WeightedDst
	4,  // 25: io.linkerd.proxy.destination.DestinationProfile.endpoint:type_name -> io.linkerd.proxy.destination.WeightedAddr
	33, // 26: io.linkerd.proxy.destination.DestinationProfile.parent_ref:type_name -> io.linkerd.proxy.meta.Metadata
	33, // 27: io.linkerd.proxy.destination.DestinationProfile.profile_ref:type_name -> io.linkerd.proxy.meta.Metadata
	14, // 28: io.linkerd.proxy.destination.Route.condition:type_name -> io.linkerd.proxy.destination.RequestMatch
	13, // 29: io.linkerd.proxy.destination.Route.response_classes:type_name -> io.linkerd.proxy.destination.ResponseClass
	29, // 30: io.linkerd.proxy.destination.Route.metrics_labels:type_name -> io.linkerd.proxy.destination.Route.MetricsLabelsEntry
	34, // 31: io.linkerd.proxy.destination.Route.timeout:type_name -> google.protobuf.Duration
	34, // 32: io.linkerd.proxy.destination.RetryBudget.ttl:type_name -> google.protobuf.Duration
	16, // 33: io.linkerd.proxy.destination.ResponseClass.condition:type_name -> io.linkerd.proxy.destination.ResponseMatch
	30, // 34: io.linkerd.proxy.destination.RequestMatch.all:type_name -> io.linkerd.proxy.destination.RequestMatch.Seq
	30, // 35: io.linkerd.proxy.destination.RequestMatch.any:type_name -> io.linkerd.proxy.destination.RequestMatch.Seq
	14, // 36: io.linkerd.proxy.destination.RequestMatch.not:type_name -> io.linkerd.proxy.destination.RequestMatch
	15, // 37: io.linkerd.proxy.destination.RequestMatch.path:type_name -> io.linkerd.proxy.destination.PathMatch
	35, // 38: io.linkerd.proxy.destination.RequestMatch.method:type_name -> io.linkerd.proxy.http_types.HttpMethod
	31, // 39: io.linkerd.proxy.destination.ResponseMatch.all:type_name -> io.linkerd.proxy.destination.ResponseMatch.Seq
	31, // 40: io.linkerd.proxy.destination.ResponseMatch.any:type_name -> io.linkerd.proxy.destination.ResponseMatch.Seq
	16, // 41: io.linkerd.proxy.destination.ResponseMatch.not:type_name -> io.linkerd.proxy.destination.ResponseMatch
	17, // 42: io.linkerd.proxy.destination.ResponseMatch.status:type_name -> io.linkerd.proxy.destination.HttpStatusRange
	33, // 43: io.linkerd.proxy.destination.WeightedDst.backend_ref:type_name -> io.linkerd.proxy.meta.Metadata
	34, // 44: io.linkerd.proxy.destination.Http2ClientParams.KeepAlive.interval:type_name -> google.protobuf.Duration
	34, // 45: io.linkerd.proxy.destination.Http2ClientParams.KeepAlive.timeout:type_name -> google.protobuf.Duration
	14, // 46: io.linkerd.proxy.destination.RequestMatch.Seq.matches:type_name -> io.linkerd.proxy.destination.RequestMatch
	16, // 47: io.linkerd.proxy.destination.ResponseMatch.Seq.matches:type_name -> io.linkerd.proxy.destination.ResponseMatch
	0,  // 48: io.linkerd.proxy.destination.Destination.Get:input_type -> io.linkerd.proxy.destination.GetDestination
	0,  // 49: io.linkerd.proxy.destination.Destination.GetProfile:input_type -> io.linkerd.proxy.destination.GetDestination
	1,  // 50: io.linkerd.proxy.destination.Destination.Get:output_type -> io.linkerd.proxy.destination.Update
	10, // 51: io.linkerd.proxy.destination.Destination.GetProfile:output_type -> io.linkerd.proxy.destination.DestinationProfile
	50, // [50:52] is the sub-list for method output_type
	48, // [48:50] is the sub-list for method input_type
	48, // [48:48] is the sub-list for extension type_name
	48, // [48:48] is the sub-list for extension extendee
	0,  // [0:48] is the sub-list for field type_name
}

func init() { file_destination_proto_init() }
func file_destination_proto_init() {
	if File_destination_proto != nil {
		return
	}
	file_destination_proto_msgTypes[1].OneofWrappers = []any{
		(*Update_Add)(nil),
		(*Update_Remove)(nil),
		(*Update_NoEndpoints)(nil),
	}
	file_destination_proto_msgTypes[5].OneofWrappers = []any{
		(*TlsIdentity_DnsLikeIdentity_)(nil),
		(*TlsIdentity_UriLikeIdentity_)(nil),
	}
	file_destination_proto_msgTypes[8].OneofWrappers = []any{
		(*ProtocolHint_H2_)(nil),
		(*ProtocolHint_Opaque_)(nil),
	}
	file_destination_proto_msgTypes[14].OneofWrappers = []any{
		(*RequestMatch_All)(nil),
		(*RequestMatch_Any)(nil),
		(*RequestMatch_Not)(nil),
		(*RequestMatch_Path)(nil),
		(*RequestMatch_Method)(nil),
	}
	file_destination_proto_msgTypes[16].OneofWrappers = []any{
		(*ResponseMatch_All)(nil),
		(*ResponseMatch_Any)(nil),
		(*ResponseMatch_Not)(nil),
		(*ResponseMatch_Status)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_destination_proto_rawDesc), len(file_destination_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   32,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_destination_proto_goTypes,
		DependencyIndexes: file_destination_proto_depIdxs,
		MessageInfos:      file_destination_proto_msgTypes,
	}.Build()
	File_destination_proto = out.File
	file_destination_proto_goTypes = nil
	file_destination_proto_depIdxs = nil
}