outlier_detection_event.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: envoy/data/cluster/v2alpha/outlier_detection_event.proto

package envoy_data_cluster_v2alpha

import (
	fmt "fmt"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Type of ejection that took place
type OutlierEjectionType int32

const (
	// In case upstream host returns certain number of consecutive 5xx.
	// If
	// :ref:`outlier_detection.split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
	// is *false*, all type of errors are treated as HTTP 5xx errors.
	// See :ref:`Cluster outlier detection <arch_overview_outlier_detection>` documentation for
	// details.
	OutlierEjectionType_CONSECUTIVE_5XX OutlierEjectionType = 0
	// In case upstream host returns certain number of consecutive gateway errors
	OutlierEjectionType_CONSECUTIVE_GATEWAY_FAILURE OutlierEjectionType = 1
	// Runs over aggregated success rate statistics from every host in cluster
	// and selects hosts for which ratio of successful replies deviates from other hosts
	// in the cluster.
	// If
	// :ref:`outlier_detection.split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
	// is *false*, all errors (externally and locally generated) are used to calculate success rate
	// statistics. See :ref:`Cluster outlier detection <arch_overview_outlier_detection>`
	// documentation for details.
	OutlierEjectionType_SUCCESS_RATE OutlierEjectionType = 2
	// Consecutive local origin failures: Connection failures, resets, timeouts, etc
	// This type of ejection happens only when
	// :ref:`outlier_detection.split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
	// is set to *true*.
	// See :ref:`Cluster outlier detection <arch_overview_outlier_detection>` documentation for
	OutlierEjectionType_CONSECUTIVE_LOCAL_ORIGIN_FAILURE OutlierEjectionType = 3
	// Runs over aggregated success rate statistics for local origin failures
	// for all hosts in the cluster and selects hosts for which success rate deviates from other
	// hosts in the cluster. This type of ejection happens only when
	// :ref:`outlier_detection.split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
	// is set to *true*.
	// See :ref:`Cluster outlier detection <arch_overview_outlier_detection>` documentation for
	OutlierEjectionType_SUCCESS_RATE_LOCAL_ORIGIN OutlierEjectionType = 4
	// Runs over aggregated success rate statistics from every host in cluster and selects hosts for
	// which ratio of failed replies is above configured value.
	OutlierEjectionType_FAILURE_PERCENTAGE OutlierEjectionType = 5
	// Runs over aggregated success rate statistics for local origin failures from every host in
	// cluster and selects hosts for which ratio of failed replies is above configured value.
	OutlierEjectionType_FAILURE_PERCENTAGE_LOCAL_ORIGIN OutlierEjectionType = 6
)

var OutlierEjectionType_name = map[int32]string{
	0: "CONSECUTIVE_5XX",
	1: "CONSECUTIVE_GATEWAY_FAILURE",
	2: "SUCCESS_RATE",
	3: "CONSECUTIVE_LOCAL_ORIGIN_FAILURE",
	4: "SUCCESS_RATE_LOCAL_ORIGIN",
	5: "FAILURE_PERCENTAGE",
	6: "FAILURE_PERCENTAGE_LOCAL_ORIGIN",
}

var OutlierEjectionType_value = map[string]int32{
	"CONSECUTIVE_5XX":                  0,
	"CONSECUTIVE_GATEWAY_FAILURE":      1,
	"SUCCESS_RATE":                     2,
	"CONSECUTIVE_LOCAL_ORIGIN_FAILURE": 3,
	"SUCCESS_RATE_LOCAL_ORIGIN":        4,
	"FAILURE_PERCENTAGE":               5,
	"FAILURE_PERCENTAGE_LOCAL_ORIGIN":  6,
}

func (x OutlierEjectionType) String() string {
	return proto.EnumName(OutlierEjectionType_name, int32(x))
}

func (OutlierEjectionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5e03c92c55863094, []int{0}
}

// Represents possible action applied to upstream host
type Action int32

const (
	// In case host was excluded from service
	Action_EJECT Action = 0
	// In case host was brought back into service
	Action_UNEJECT Action = 1
)

var Action_name = map[int32]string{
	0: "EJECT",
	1: "UNEJECT",
}

var Action_value = map[string]int32{
	"EJECT":   0,
	"UNEJECT": 1,
}

func (x Action) String() string {
	return proto.EnumName(Action_name, int32(x))
}

func (Action) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5e03c92c55863094, []int{1}
}

// [#next-free-field: 12]
type OutlierDetectionEvent struct {
	// In case of eject represents type of ejection that took place.
	Type OutlierEjectionType `protobuf:"varint,1,opt,name=type,proto3,enum=envoy.data.cluster.v2alpha.OutlierEjectionType" json:"type,omitempty"`
	// Timestamp for event.
	Timestamp *types.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// The time in seconds since the last action (either an ejection or unejection) took place.
	SecsSinceLastAction *types.UInt64Value `protobuf:"bytes,3,opt,name=secs_since_last_action,json=secsSinceLastAction,proto3" json:"secs_since_last_action,omitempty"`
	// The :ref:`cluster <envoy_api_msg_Cluster>` that owns the ejected host.
	ClusterName string `protobuf:"bytes,4,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
	// The URL of the ejected host. E.g., ``tcp://1.2.3.4:80``.
	UpstreamUrl string `protobuf:"bytes,5,opt,name=upstream_url,json=upstreamUrl,proto3" json:"upstream_url,omitempty"`
	// The action that took place.
	Action Action `protobuf:"varint,6,opt,name=action,proto3,enum=envoy.data.cluster.v2alpha.Action" json:"action,omitempty"`
	// If ``action`` is ``eject``, specifies the number of times the host has been ejected (local to
	// that Envoy and gets reset if the host gets removed from the upstream cluster for any reason and
	// then re-added).
	NumEjections uint32 `protobuf:"varint,7,opt,name=num_ejections,json=numEjections,proto3" json:"num_ejections,omitempty"`
	// If ``action`` is ``eject``, specifies if the ejection was enforced. ``true`` means the host was
	// ejected. ``false`` means the event was logged but the host was not actually ejected.
	Enforced bool `protobuf:"varint,8,opt,name=enforced,proto3" json:"enforced,omitempty"`
	// Types that are valid to be assigned to Event:
	//	*OutlierDetectionEvent_EjectSuccessRateEvent
	//	*OutlierDetectionEvent_EjectConsecutiveEvent
	//	*OutlierDetectionEvent_EjectFailurePercentageEvent
	Event                isOutlierDetectionEvent_Event `protobuf_oneof:"event"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *OutlierDetectionEvent) Reset()         { *m = OutlierDetectionEvent{} }
func (m *OutlierDetectionEvent) String() string { return proto.CompactTextString(m) }
func (*OutlierDetectionEvent) ProtoMessage()    {}
func (*OutlierDetectionEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_5e03c92c55863094, []int{0}
}
func (m *OutlierDetectionEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutlierDetectionEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutlierDetectionEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutlierDetectionEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutlierDetectionEvent.Merge(m, src)
}
func (m *OutlierDetectionEvent) XXX_Size() int {
	return m.Size()
}
func (m *OutlierDetectionEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_OutlierDetectionEvent.DiscardUnknown(m)
}

var xxx_messageInfo_OutlierDetectionEvent proto.InternalMessageInfo

type isOutlierDetectionEvent_Event interface {
	isOutlierDetectionEvent_Event()
	MarshalTo([]byte) (int, error)
	Size() int
}

type OutlierDetectionEvent_EjectSuccessRateEvent struct {
	EjectSuccessRateEvent *OutlierEjectSuccessRate `protobuf:"bytes,9,opt,name=eject_success_rate_event,json=ejectSuccessRateEvent,proto3,oneof"`
}
type OutlierDetectionEvent_EjectConsecutiveEvent struct {
	EjectConsecutiveEvent *OutlierEjectConsecutive `protobuf:"bytes,10,opt,name=eject_consecutive_event,json=ejectConsecutiveEvent,proto3,oneof"`
}
type OutlierDetectionEvent_EjectFailurePercentageEvent struct {
	EjectFailurePercentageEvent *OutlierEjectFailurePercentage `protobuf:"bytes,11,opt,name=eject_failure_percentage_event,json=ejectFailurePercentageEvent,proto3,oneof"`
}

func (*OutlierDetectionEvent_EjectSuccessRateEvent) isOutlierDetectionEvent_Event()       {}
func (*OutlierDetectionEvent_EjectConsecutiveEvent) isOutlierDetectionEvent_Event()       {}
func (*OutlierDetectionEvent_EjectFailurePercentageEvent) isOutlierDetectionEvent_Event() {}

func (m *OutlierDetectionEvent) GetEvent() isOutlierDetectionEvent_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *OutlierDetectionEvent) GetType() OutlierEjectionType {
	if m != nil {
		return m.Type
	}
	return OutlierEjectionType_CONSECUTIVE_5XX
}

func (m *OutlierDetectionEvent) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *OutlierDetectionEvent) GetSecsSinceLastAction() *types.UInt64Value {
	if m != nil {
		return m.SecsSinceLastAction
	}
	return nil
}

func (m *OutlierDetectionEvent) GetClusterName() string {
	if m != nil {
		return m.ClusterName
	}
	return ""
}

func (m *OutlierDetectionEvent) GetUpstreamUrl() string {
	if m != nil {
		return m.UpstreamUrl
	}
	return ""
}

func (m *OutlierDetectionEvent) GetAction() Action {
	if m != nil {
		return m.Action
	}
	return Action_EJECT
}

func (m *OutlierDetectionEvent) GetNumEjections() uint32 {
	if m != nil {
		return m.NumEjections
	}
	return 0
}

func (m *OutlierDetectionEvent) GetEnforced() bool {
	if m != nil {
		return m.Enforced
	}
	return false
}

func (m *OutlierDetectionEvent) GetEjectSuccessRateEvent() *OutlierEjectSuccessRate {
	if x, ok := m.GetEvent().(*OutlierDetectionEvent_EjectSuccessRateEvent); ok {
		return x.EjectSuccessRateEvent
	}
	return nil
}

func (m *OutlierDetectionEvent) GetEjectConsecutiveEvent() *OutlierEjectConsecutive {
	if x, ok := m.GetEvent().(*OutlierDetectionEvent_EjectConsecutiveEvent); ok {
		return x.EjectConsecutiveEvent
	}
	return nil
}

func (m *OutlierDetectionEvent) GetEjectFailurePercentageEvent() *OutlierEjectFailurePercentage {
	if x, ok := m.GetEvent().(*OutlierDetectionEvent_EjectFailurePercentageEvent); ok {
		return x.EjectFailurePercentageEvent
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*OutlierDetectionEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*OutlierDetectionEvent_EjectSuccessRateEvent)(nil),
		(*OutlierDetectionEvent_EjectConsecutiveEvent)(nil),
		(*OutlierDetectionEvent_EjectFailurePercentageEvent)(nil),
	}
}

type OutlierEjectSuccessRate struct {
	// Host’s success rate at the time of the ejection event on a 0-100 range.
	HostSuccessRate uint32 `protobuf:"varint,1,opt,name=host_success_rate,json=hostSuccessRate,proto3" json:"host_success_rate,omitempty"`
	// Average success rate of the hosts in the cluster at the time of the ejection event on a 0-100
	// range.
	ClusterAverageSuccessRate uint32 `protobuf:"varint,2,opt,name=cluster_average_success_rate,json=clusterAverageSuccessRate,proto3" json:"cluster_average_success_rate,omitempty"`
	// Success rate ejection threshold at the time of the ejection event.
	ClusterSuccessRateEjectionThreshold uint32   `protobuf:"varint,3,opt,name=cluster_success_rate_ejection_threshold,json=clusterSuccessRateEjectionThreshold,proto3" json:"cluster_success_rate_ejection_threshold,omitempty"`
	XXX_NoUnkeyedLiteral                struct{} `json:"-"`
	XXX_unrecognized                    []byte   `json:"-"`
	XXX_sizecache                       int32    `json:"-"`
}

func (m *OutlierEjectSuccessRate) Reset()         { *m = OutlierEjectSuccessRate{} }
func (m *OutlierEjectSuccessRate) String() string { return proto.CompactTextString(m) }
func (*OutlierEjectSuccessRate) ProtoMessage()    {}
func (*OutlierEjectSuccessRate) Descriptor() ([]byte, []int) {
	return fileDescriptor_5e03c92c55863094, []int{1}
}
func (m *OutlierEjectSuccessRate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutlierEjectSuccessRate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutlierEjectSuccessRate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutlierEjectSuccessRate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutlierEjectSuccessRate.Merge(m, src)
}
func (m *OutlierEjectSuccessRate) XXX_Size() int {
	return m.Size()
}
func (m *OutlierEjectSuccessRate) XXX_DiscardUnknown() {
	xxx_messageInfo_OutlierEjectSuccessRate.DiscardUnknown(m)
}

var xxx_messageInfo_OutlierEjectSuccessRate proto.InternalMessageInfo

func (m *OutlierEjectSuccessRate) GetHostSuccessRate() uint32 {
	if m != nil {
		return m.HostSuccessRate
	}
	return 0
}

func (m *OutlierEjectSuccessRate) GetClusterAverageSuccessRate() uint32 {
	if m != nil {
		return m.ClusterAverageSuccessRate
	}
	return 0
}

func (m *OutlierEjectSuccessRate) GetClusterSuccessRateEjectionThreshold() uint32 {
	if m != nil {
		return m.ClusterSuccessRateEjectionThreshold
	}
	return 0
}

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

func (m *OutlierEjectConsecutive) Reset()         { *m = OutlierEjectConsecutive{} }
func (m *OutlierEjectConsecutive) String() string { return proto.CompactTextString(m) }
func (*OutlierEjectConsecutive) ProtoMessage()    {}
func (*OutlierEjectConsecutive) Descriptor() ([]byte, []int) {
	return fileDescriptor_5e03c92c55863094, []int{2}
}
func (m *OutlierEjectConsecutive) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutlierEjectConsecutive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutlierEjectConsecutive.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutlierEjectConsecutive) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutlierEjectConsecutive.Merge(m, src)
}
func (m *OutlierEjectConsecutive) XXX_Size() int {
	return m.Size()
}
func (m *OutlierEjectConsecutive) XXX_DiscardUnknown() {
	xxx_messageInfo_OutlierEjectConsecutive.DiscardUnknown(m)
}

var xxx_messageInfo_OutlierEjectConsecutive proto.InternalMessageInfo

type OutlierEjectFailurePercentage struct {
	// Host's success rate at the time of the ejection event on a 0-100 range.
	HostSuccessRate      uint32   `protobuf:"varint,1,opt,name=host_success_rate,json=hostSuccessRate,proto3" json:"host_success_rate,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OutlierEjectFailurePercentage) Reset()         { *m = OutlierEjectFailurePercentage{} }
func (m *OutlierEjectFailurePercentage) String() string { return proto.CompactTextString(m) }
func (*OutlierEjectFailurePercentage) ProtoMessage()    {}
func (*OutlierEjectFailurePercentage) Descriptor() ([]byte, []int) {
	return fileDescriptor_5e03c92c55863094, []int{3}
}
func (m *OutlierEjectFailurePercentage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutlierEjectFailurePercentage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutlierEjectFailurePercentage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutlierEjectFailurePercentage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutlierEjectFailurePercentage.Merge(m, src)
}
func (m *OutlierEjectFailurePercentage) XXX_Size() int {
	return m.Size()
}
func (m *OutlierEjectFailurePercentage) XXX_DiscardUnknown() {
	xxx_messageInfo_OutlierEjectFailurePercentage.DiscardUnknown(m)
}

var xxx_messageInfo_OutlierEjectFailurePercentage proto.InternalMessageInfo

func (m *OutlierEjectFailurePercentage) GetHostSuccessRate() uint32 {
	if m != nil {
		return m.HostSuccessRate
	}
	return 0
}

func init() {
	proto.RegisterEnum("envoy.data.cluster.v2alpha.OutlierEjectionType", OutlierEjectionType_name, OutlierEjectionType_value)
	proto.RegisterEnum("envoy.data.cluster.v2alpha.Action", Action_name, Action_value)
	proto.RegisterType((*OutlierDetectionEvent)(nil), "envoy.data.cluster.v2alpha.OutlierDetectionEvent")
	proto.RegisterType((*OutlierEjectSuccessRate)(nil), "envoy.data.cluster.v2alpha.OutlierEjectSuccessRate")
	proto.RegisterType((*OutlierEjectConsecutive)(nil), "envoy.data.cluster.v2alpha.OutlierEjectConsecutive")
	proto.RegisterType((*OutlierEjectFailurePercentage)(nil), "envoy.data.cluster.v2alpha.OutlierEjectFailurePercentage")
}

func init() {
	proto.RegisterFile("envoy/data/cluster/v2alpha/outlier_detection_event.proto", fileDescriptor_5e03c92c55863094)
}

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

func (m *OutlierDetectionEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutlierDetectionEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutlierDetectionEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Event != nil {
		{
			size := m.Event.Size()
			i -= size
			if _, err := m.Event.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Enforced {
		i--
		if m.Enforced {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.NumEjections != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.NumEjections))
		i--
		dAtA[i] = 0x38
	}
	if m.Action != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.Action))
		i--
		dAtA[i] = 0x30
	}
	if len(m.UpstreamUrl) > 0 {
		i -= len(m.UpstreamUrl)
		copy(dAtA[i:], m.UpstreamUrl)
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(len(m.UpstreamUrl)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ClusterName) > 0 {
		i -= len(m.ClusterName)
		copy(dAtA[i:], m.ClusterName)
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(len(m.ClusterName)))
		i--
		dAtA[i] = 0x22
	}
	if m.SecsSinceLastAction != nil {
		{
			size, err := m.SecsSinceLastAction.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OutlierDetectionEvent_EjectSuccessRateEvent) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OutlierDetectionEvent_EjectSuccessRateEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EjectSuccessRateEvent != nil {
		{
			size, err := m.EjectSuccessRateEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *OutlierDetectionEvent_EjectConsecutiveEvent) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OutlierDetectionEvent_EjectConsecutiveEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EjectConsecutiveEvent != nil {
		{
			size, err := m.EjectConsecutiveEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *OutlierDetectionEvent_EjectFailurePercentageEvent) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OutlierDetectionEvent_EjectFailurePercentageEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EjectFailurePercentageEvent != nil {
		{
			size, err := m.EjectFailurePercentageEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *OutlierEjectSuccessRate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutlierEjectSuccessRate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutlierEjectSuccessRate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ClusterSuccessRateEjectionThreshold != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.ClusterSuccessRateEjectionThreshold))
		i--
		dAtA[i] = 0x18
	}
	if m.ClusterAverageSuccessRate != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.ClusterAverageSuccessRate))
		i--
		dAtA[i] = 0x10
	}
	if m.HostSuccessRate != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.HostSuccessRate))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OutlierEjectConsecutive) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutlierEjectConsecutive) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutlierEjectConsecutive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *OutlierEjectFailurePercentage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutlierEjectFailurePercentage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutlierEjectFailurePercentage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.HostSuccessRate != 0 {
		i = encodeVarintOutlierDetectionEvent(dAtA, i, uint64(m.HostSuccessRate))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintOutlierDetectionEvent(dAtA []byte, offset int, v uint64) int {
	offset -= sovOutlierDetectionEvent(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *OutlierDetectionEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.Type))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	if m.SecsSinceLastAction != nil {
		l = m.SecsSinceLastAction.Size()
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	l = len(m.ClusterName)
	if l > 0 {
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	l = len(m.UpstreamUrl)
	if l > 0 {
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	if m.Action != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.Action))
	}
	if m.NumEjections != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.NumEjections))
	}
	if m.Enforced {
		n += 2
	}
	if m.Event != nil {
		n += m.Event.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutlierDetectionEvent_EjectSuccessRateEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EjectSuccessRateEvent != nil {
		l = m.EjectSuccessRateEvent.Size()
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	return n
}
func (m *OutlierDetectionEvent_EjectConsecutiveEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EjectConsecutiveEvent != nil {
		l = m.EjectConsecutiveEvent.Size()
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	return n
}
func (m *OutlierDetectionEvent_EjectFailurePercentageEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EjectFailurePercentageEvent != nil {
		l = m.EjectFailurePercentageEvent.Size()
		n += 1 + l + sovOutlierDetectionEvent(uint64(l))
	}
	return n
}
func (m *OutlierEjectSuccessRate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HostSuccessRate != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.HostSuccessRate))
	}
	if m.ClusterAverageSuccessRate != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.ClusterAverageSuccessRate))
	}
	if m.ClusterSuccessRateEjectionThreshold != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.ClusterSuccessRateEjectionThreshold))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutlierEjectConsecutive) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutlierEjectFailurePercentage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HostSuccessRate != 0 {
		n += 1 + sovOutlierDetectionEvent(uint64(m.HostSuccessRate))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovOutlierDetectionEvent(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozOutlierDetectionEvent(x uint64) (n int) {
	return sovOutlierDetectionEvent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *OutlierDetectionEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOutlierDetectionEvent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutlierDetectionEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutlierDetectionEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= OutlierEjectionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecsSinceLastAction", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SecsSinceLastAction == nil {
				m.SecsSinceLastAction = &types.UInt64Value{}
			}
			if err := m.SecsSinceLastAction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpstreamUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpstreamUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= Action(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumEjections", wireType)
			}
			m.NumEjections = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumEjections |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enforced", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enforced = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EjectSuccessRateEvent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OutlierEjectSuccessRate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &OutlierDetectionEvent_EjectSuccessRateEvent{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EjectConsecutiveEvent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OutlierEjectConsecutive{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &OutlierDetectionEvent_EjectConsecutiveEvent{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EjectFailurePercentageEvent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OutlierEjectFailurePercentage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &OutlierDetectionEvent_EjectFailurePercentageEvent{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOutlierDetectionEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutlierEjectSuccessRate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOutlierDetectionEvent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutlierEjectSuccessRate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutlierEjectSuccessRate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostSuccessRate", wireType)
			}
			m.HostSuccessRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HostSuccessRate |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterAverageSuccessRate", wireType)
			}
			m.ClusterAverageSuccessRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClusterAverageSuccessRate |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterSuccessRateEjectionThreshold", wireType)
			}
			m.ClusterSuccessRateEjectionThreshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClusterSuccessRateEjectionThreshold |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOutlierDetectionEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutlierEjectConsecutive) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOutlierDetectionEvent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutlierEjectConsecutive: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutlierEjectConsecutive: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipOutlierDetectionEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutlierEjectFailurePercentage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOutlierDetectionEvent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutlierEjectFailurePercentage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutlierEjectFailurePercentage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostSuccessRate", wireType)
			}
			m.HostSuccessRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HostSuccessRate |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOutlierDetectionEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthOutlierDetectionEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipOutlierDetectionEvent(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowOutlierDetectionEvent
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowOutlierDetectionEvent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthOutlierDetectionEvent
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthOutlierDetectionEvent
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowOutlierDetectionEvent
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipOutlierDetectionEvent(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthOutlierDetectionEvent
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthOutlierDetectionEvent = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowOutlierDetectionEvent   = fmt.Errorf("proto: integer overflow")
)