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

package pipeline_v1

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"

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

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

type MonitoringInfoSpecs_Enum int32

const (
	// TODO(BEAM-6926): Add the PTRANSFORM name as a required label after
	// upgrading the python SDK.
	MonitoringInfoSpecs_USER_COUNTER         MonitoringInfoSpecs_Enum = 0
	MonitoringInfoSpecs_ELEMENT_COUNT        MonitoringInfoSpecs_Enum = 1
	MonitoringInfoSpecs_SAMPLED_BYTE_SIZE    MonitoringInfoSpecs_Enum = 7
	MonitoringInfoSpecs_START_BUNDLE_MSECS   MonitoringInfoSpecs_Enum = 2
	MonitoringInfoSpecs_PROCESS_BUNDLE_MSECS MonitoringInfoSpecs_Enum = 3
	MonitoringInfoSpecs_FINISH_BUNDLE_MSECS  MonitoringInfoSpecs_Enum = 4
	MonitoringInfoSpecs_TOTAL_MSECS          MonitoringInfoSpecs_Enum = 5
	// TODO(BEAM-6926): Add the PTRANSFORM name as a required label after
	// upgrading the python SDK.
	MonitoringInfoSpecs_USER_DISTRIBUTION_COUNTER MonitoringInfoSpecs_Enum = 6
)

var MonitoringInfoSpecs_Enum_name = map[int32]string{
	0: "USER_COUNTER",
	1: "ELEMENT_COUNT",
	7: "SAMPLED_BYTE_SIZE",
	2: "START_BUNDLE_MSECS",
	3: "PROCESS_BUNDLE_MSECS",
	4: "FINISH_BUNDLE_MSECS",
	5: "TOTAL_MSECS",
	6: "USER_DISTRIBUTION_COUNTER",
}
var MonitoringInfoSpecs_Enum_value = map[string]int32{
	"USER_COUNTER":              0,
	"ELEMENT_COUNT":             1,
	"SAMPLED_BYTE_SIZE":         7,
	"START_BUNDLE_MSECS":        2,
	"PROCESS_BUNDLE_MSECS":      3,
	"FINISH_BUNDLE_MSECS":       4,
	"TOTAL_MSECS":               5,
	"USER_DISTRIBUTION_COUNTER": 6,
}

func (x MonitoringInfoSpecs_Enum) String() string {
	return proto.EnumName(MonitoringInfoSpecs_Enum_name, int32(x))
}
func (MonitoringInfoSpecs_Enum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_metrics_f27e09e153e79ab4, []int{2, 0}
}

type MonitoringInfo_MonitoringInfoLabels int32

const (
	// The values used for TRANSFORM, PCOLLECTION, WINDOWING_STRATEGY
	// CODER, ENVIRONMENT, etc. must always match the keys used to
	// refer to them in the ProcessBundleDescriptor.
	MonitoringInfo_TRANSFORM          MonitoringInfo_MonitoringInfoLabels = 0
	MonitoringInfo_PCOLLECTION        MonitoringInfo_MonitoringInfoLabels = 1
	MonitoringInfo_WINDOWING_STRATEGY MonitoringInfo_MonitoringInfoLabels = 2
	MonitoringInfo_CODER              MonitoringInfo_MonitoringInfoLabels = 3
	MonitoringInfo_ENVIRONMENT        MonitoringInfo_MonitoringInfoLabels = 4
	MonitoringInfo_NAMESPACE          MonitoringInfo_MonitoringInfoLabels = 5
	MonitoringInfo_NAME               MonitoringInfo_MonitoringInfoLabels = 6
)

var MonitoringInfo_MonitoringInfoLabels_name = map[int32]string{
	0: "TRANSFORM",
	1: "PCOLLECTION",
	2: "WINDOWING_STRATEGY",
	3: "CODER",
	4: "ENVIRONMENT",
	5: "NAMESPACE",
	6: "NAME",
}
var MonitoringInfo_MonitoringInfoLabels_value = map[string]int32{
	"TRANSFORM":          0,
	"PCOLLECTION":        1,
	"WINDOWING_STRATEGY": 2,
	"CODER":              3,
	"ENVIRONMENT":        4,
	"NAMESPACE":          5,
	"NAME":               6,
}

func (x MonitoringInfo_MonitoringInfoLabels) String() string {
	return proto.EnumName(MonitoringInfo_MonitoringInfoLabels_name, int32(x))
}
func (MonitoringInfo_MonitoringInfoLabels) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_metrics_f27e09e153e79ab4, []int{4, 0}
}

type MonitoringInfoTypeUrns_Enum int32

const (
	MonitoringInfoTypeUrns_SUM_INT64_TYPE          MonitoringInfoTypeUrns_Enum = 0
	MonitoringInfoTypeUrns_DISTRIBUTION_INT64_TYPE MonitoringInfoTypeUrns_Enum = 1
	MonitoringInfoTypeUrns_LATEST_INT64_TYPE       MonitoringInfoTypeUrns_Enum = 2
)

var MonitoringInfoTypeUrns_Enum_name = map[int32]string{
	0: "SUM_INT64_TYPE",
	1: "DISTRIBUTION_INT64_TYPE",
	2: "LATEST_INT64_TYPE",
}
var MonitoringInfoTypeUrns_Enum_value = map[string]int32{
	"SUM_INT64_TYPE":          0,
	"DISTRIBUTION_INT64_TYPE": 1,
	"LATEST_INT64_TYPE":       2,
}

func (x MonitoringInfoTypeUrns_Enum) String() string {
	return proto.EnumName(MonitoringInfoTypeUrns_Enum_name, int32(x))
}
func (MonitoringInfoTypeUrns_Enum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_metrics_f27e09e153e79ab4, []int{5, 0}
}

// A specification containing required set of fields and labels required
// to be set on a MonitoringInfo for the specific URN for SDK->RunnerHarness
// ProcessBundleResponse reporting.
type MonitoringInfoSpec struct {
	Urn     string `protobuf:"bytes,1,opt,name=urn,proto3" json:"urn,omitempty"`
	TypeUrn string `protobuf:"bytes,2,opt,name=type_urn,json=typeUrn,proto3" json:"type_urn,omitempty"`
	// The list of required
	RequiredLabels []string `protobuf:"bytes,3,rep,name=required_labels,json=requiredLabels,proto3" json:"required_labels,omitempty"`
	// Extra non functional parts of the spec for descriptive purposes.
	// i.e. description, units, etc.
	Annotations          []*Annotation `protobuf:"bytes,4,rep,name=annotations,proto3" json:"annotations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_MonitoringInfoSpec proto.InternalMessageInfo

func (m *MonitoringInfoSpec) GetUrn() string {
	if m != nil {
		return m.Urn
	}
	return ""
}

func (m *MonitoringInfoSpec) GetTypeUrn() string {
	if m != nil {
		return m.TypeUrn
	}
	return ""
}

func (m *MonitoringInfoSpec) GetRequiredLabels() []string {
	if m != nil {
		return m.RequiredLabels
	}
	return nil
}

func (m *MonitoringInfoSpec) GetAnnotations() []*Annotation {
	if m != nil {
		return m.Annotations
	}
	return nil
}

// The key name and value string of MonitoringInfo annotations.
type Annotation struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Annotation proto.InternalMessageInfo

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

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

// Populated MonitoringInfoSpecs for specific URNs.
// Indicating the required fields to be set.
// SDKs and RunnerHarnesses can load these instances into memory and write a
// validator or code generator to assist with populating and validating
// MonitoringInfo protos.
type MonitoringInfoSpecs struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MonitoringInfoSpecs proto.InternalMessageInfo

// A set of properties for the MonitoringInfoLabel, this is useful to obtain
// the proper label string for the MonitoringInfoLabel.
type MonitoringInfoLabelProps struct {
	// The label key to use in the MonitoringInfo labels map.
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MonitoringInfoLabelProps proto.InternalMessageInfo

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

type MonitoringInfo struct {
	// The name defining the metric or monitored state.
	Urn string `protobuf:"bytes,1,opt,name=urn,proto3" json:"urn,omitempty"`
	// This is specified as a URN that implies:
	// A message class: (Distribution, Counter, Extrema, MonitoringDataTable).
	// Sub types like field formats - int64, double, string.
	// Aggregation methods - SUM, LATEST, TOP-N, BOTTOM-N, DISTRIBUTION
	// valid values are:
	// beam:metrics:[sum_int_64|latest_int_64|top_n_int_64|bottom_n_int_64|
	//     sum_double|latest_double|top_n_double|bottom_n_double|
	//     distribution_int_64|distribution_double|monitoring_data_table
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	// The Metric or monitored state.
	//
	// Types that are valid to be assigned to Data:
	//	*MonitoringInfo_MonitoringTableData
	//	*MonitoringInfo_Metric
	Data isMonitoringInfo_Data `protobuf_oneof:"data"`
	// A set of key+value labels which define the scope of the metric.
	// Either a well defined entity id for matching the enum names in
	// the MonitoringInfoLabels enum or any arbitrary label
	// set by a custom metric or user metric.
	// A monitoring system is expected to be able to aggregate the metrics
	// together for all updates having the same URN and labels. Some systems such
	// as Stackdriver will be able to aggregate the metrics using a subset of the
	// provided labels
	Labels map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// The walltime of the most recent update.
	// Useful for aggregation for latest types such as LatestInt64.
	Timestamp            *timestamp.Timestamp `protobuf:"bytes,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_MonitoringInfo proto.InternalMessageInfo

type isMonitoringInfo_Data interface {
	isMonitoringInfo_Data()
}

type MonitoringInfo_MonitoringTableData struct {
	MonitoringTableData *MonitoringTableData `protobuf:"bytes,3,opt,name=monitoring_table_data,json=monitoringTableData,proto3,oneof"`
}
type MonitoringInfo_Metric struct {
	Metric *Metric `protobuf:"bytes,4,opt,name=metric,proto3,oneof"`
}

func (*MonitoringInfo_MonitoringTableData) isMonitoringInfo_Data() {}
func (*MonitoringInfo_Metric) isMonitoringInfo_Data()              {}

func (m *MonitoringInfo) GetData() isMonitoringInfo_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *MonitoringInfo) GetUrn() string {
	if m != nil {
		return m.Urn
	}
	return ""
}

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

func (m *MonitoringInfo) GetMonitoringTableData() *MonitoringTableData {
	if x, ok := m.GetData().(*MonitoringInfo_MonitoringTableData); ok {
		return x.MonitoringTableData
	}
	return nil
}

func (m *MonitoringInfo) GetMetric() *Metric {
	if x, ok := m.GetData().(*MonitoringInfo_Metric); ok {
		return x.Metric
	}
	return nil
}

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

func (m *MonitoringInfo) GetTimestamp() *timestamp.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*MonitoringInfo) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _MonitoringInfo_OneofMarshaler, _MonitoringInfo_OneofUnmarshaler, _MonitoringInfo_OneofSizer, []interface{}{
		(*MonitoringInfo_MonitoringTableData)(nil),
		(*MonitoringInfo_Metric)(nil),
	}
}

func _MonitoringInfo_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*MonitoringInfo)
	// data
	switch x := m.Data.(type) {
	case *MonitoringInfo_MonitoringTableData:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MonitoringTableData); err != nil {
			return err
		}
	case *MonitoringInfo_Metric:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Metric); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("MonitoringInfo.Data has unexpected type %T", x)
	}
	return nil
}

func _MonitoringInfo_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*MonitoringInfo)
	switch tag {
	case 3: // data.monitoring_table_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MonitoringTableData)
		err := b.DecodeMessage(msg)
		m.Data = &MonitoringInfo_MonitoringTableData{msg}
		return true, err
	case 4: // data.metric
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Metric)
		err := b.DecodeMessage(msg)
		m.Data = &MonitoringInfo_Metric{msg}
		return true, err
	default:
		return false, nil
	}
}

func _MonitoringInfo_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*MonitoringInfo)
	// data
	switch x := m.Data.(type) {
	case *MonitoringInfo_MonitoringTableData:
		s := proto.Size(x.MonitoringTableData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *MonitoringInfo_Metric:
		s := proto.Size(x.Metric)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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

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

var xxx_messageInfo_MonitoringInfoTypeUrns proto.InternalMessageInfo

type Metric struct {
	// (Required) The data for this metric.
	//
	// Types that are valid to be assigned to Data:
	//	*Metric_CounterData
	//	*Metric_DistributionData
	//	*Metric_ExtremaData
	Data                 isMetric_Data `protobuf_oneof:"data"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Metric proto.InternalMessageInfo

type isMetric_Data interface {
	isMetric_Data()
}

type Metric_CounterData struct {
	CounterData *CounterData `protobuf:"bytes,1,opt,name=counter_data,json=counterData,proto3,oneof"`
}
type Metric_DistributionData struct {
	DistributionData *DistributionData `protobuf:"bytes,2,opt,name=distribution_data,json=distributionData,proto3,oneof"`
}
type Metric_ExtremaData struct {
	ExtremaData *ExtremaData `protobuf:"bytes,3,opt,name=extrema_data,json=extremaData,proto3,oneof"`
}

func (*Metric_CounterData) isMetric_Data()      {}
func (*Metric_DistributionData) isMetric_Data() {}
func (*Metric_ExtremaData) isMetric_Data()      {}

func (m *Metric) GetData() isMetric_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Metric) GetCounterData() *CounterData {
	if x, ok := m.GetData().(*Metric_CounterData); ok {
		return x.CounterData
	}
	return nil
}

func (m *Metric) GetDistributionData() *DistributionData {
	if x, ok := m.GetData().(*Metric_DistributionData); ok {
		return x.DistributionData
	}
	return nil
}

func (m *Metric) GetExtremaData() *ExtremaData {
	if x, ok := m.GetData().(*Metric_ExtremaData); ok {
		return x.ExtremaData
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Metric) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Metric_OneofMarshaler, _Metric_OneofUnmarshaler, _Metric_OneofSizer, []interface{}{
		(*Metric_CounterData)(nil),
		(*Metric_DistributionData)(nil),
		(*Metric_ExtremaData)(nil),
	}
}

func _Metric_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Metric)
	// data
	switch x := m.Data.(type) {
	case *Metric_CounterData:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CounterData); err != nil {
			return err
		}
	case *Metric_DistributionData:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DistributionData); err != nil {
			return err
		}
	case *Metric_ExtremaData:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ExtremaData); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Metric.Data has unexpected type %T", x)
	}
	return nil
}

func _Metric_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Metric)
	switch tag {
	case 1: // data.counter_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CounterData)
		err := b.DecodeMessage(msg)
		m.Data = &Metric_CounterData{msg}
		return true, err
	case 2: // data.distribution_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DistributionData)
		err := b.DecodeMessage(msg)
		m.Data = &Metric_DistributionData{msg}
		return true, err
	case 3: // data.extrema_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ExtremaData)
		err := b.DecodeMessage(msg)
		m.Data = &Metric_ExtremaData{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Metric_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Metric)
	// data
	switch x := m.Data.(type) {
	case *Metric_CounterData:
		s := proto.Size(x.CounterData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Metric_DistributionData:
		s := proto.Size(x.DistributionData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Metric_ExtremaData:
		s := proto.Size(x.ExtremaData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Data associated with a Counter or Gauge metric.
// This is designed to be compatible with metric collection
// systems such as DropWizard.
type CounterData struct {
	// Types that are valid to be assigned to Value:
	//	*CounterData_Int64Value
	//	*CounterData_DoubleValue
	//	*CounterData_StringValue
	Value                isCounterData_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_CounterData proto.InternalMessageInfo

type isCounterData_Value interface {
	isCounterData_Value()
}

type CounterData_Int64Value struct {
	Int64Value int64 `protobuf:"varint,1,opt,name=int64_value,json=int64Value,proto3,oneof"`
}
type CounterData_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,2,opt,name=double_value,json=doubleValue,proto3,oneof"`
}
type CounterData_StringValue struct {
	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}

func (*CounterData_Int64Value) isCounterData_Value()  {}
func (*CounterData_DoubleValue) isCounterData_Value() {}
func (*CounterData_StringValue) isCounterData_Value() {}

func (m *CounterData) GetValue() isCounterData_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *CounterData) GetInt64Value() int64 {
	if x, ok := m.GetValue().(*CounterData_Int64Value); ok {
		return x.Int64Value
	}
	return 0
}

func (m *CounterData) GetDoubleValue() float64 {
	if x, ok := m.GetValue().(*CounterData_DoubleValue); ok {
		return x.DoubleValue
	}
	return 0
}

func (m *CounterData) GetStringValue() string {
	if x, ok := m.GetValue().(*CounterData_StringValue); ok {
		return x.StringValue
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*CounterData) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _CounterData_OneofMarshaler, _CounterData_OneofUnmarshaler, _CounterData_OneofSizer, []interface{}{
		(*CounterData_Int64Value)(nil),
		(*CounterData_DoubleValue)(nil),
		(*CounterData_StringValue)(nil),
	}
}

func _CounterData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*CounterData)
	// value
	switch x := m.Value.(type) {
	case *CounterData_Int64Value:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Int64Value))
	case *CounterData_DoubleValue:
		b.EncodeVarint(2<<3 | proto.WireFixed64)
		b.EncodeFixed64(math.Float64bits(x.DoubleValue))
	case *CounterData_StringValue:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.StringValue)
	case nil:
	default:
		return fmt.Errorf("CounterData.Value has unexpected type %T", x)
	}
	return nil
}

func _CounterData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*CounterData)
	switch tag {
	case 1: // value.int64_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &CounterData_Int64Value{int64(x)}
		return true, err
	case 2: // value.double_value
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.Value = &CounterData_DoubleValue{math.Float64frombits(x)}
		return true, err
	case 3: // value.string_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &CounterData_StringValue{x}
		return true, err
	default:
		return false, nil
	}
}

func _CounterData_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*CounterData)
	// value
	switch x := m.Value.(type) {
	case *CounterData_Int64Value:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Int64Value))
	case *CounterData_DoubleValue:
		n += 1 // tag and wire
		n += 8
	case *CounterData_StringValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.StringValue)))
		n += len(x.StringValue)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Extrema messages are used for calculating
// Top-N/Bottom-N metrics.
type ExtremaData struct {
	// Types that are valid to be assigned to Extrema:
	//	*ExtremaData_IntExtremaData
	//	*ExtremaData_DoubleExtremaData
	Extrema              isExtremaData_Extrema `protobuf_oneof:"extrema"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_ExtremaData proto.InternalMessageInfo

type isExtremaData_Extrema interface {
	isExtremaData_Extrema()
}

type ExtremaData_IntExtremaData struct {
	IntExtremaData *IntExtremaData `protobuf:"bytes,1,opt,name=int_extrema_data,json=intExtremaData,proto3,oneof"`
}
type ExtremaData_DoubleExtremaData struct {
	DoubleExtremaData *DoubleExtremaData `protobuf:"bytes,2,opt,name=double_extrema_data,json=doubleExtremaData,proto3,oneof"`
}

func (*ExtremaData_IntExtremaData) isExtremaData_Extrema()    {}
func (*ExtremaData_DoubleExtremaData) isExtremaData_Extrema() {}

func (m *ExtremaData) GetExtrema() isExtremaData_Extrema {
	if m != nil {
		return m.Extrema
	}
	return nil
}

func (m *ExtremaData) GetIntExtremaData() *IntExtremaData {
	if x, ok := m.GetExtrema().(*ExtremaData_IntExtremaData); ok {
		return x.IntExtremaData
	}
	return nil
}

func (m *ExtremaData) GetDoubleExtremaData() *DoubleExtremaData {
	if x, ok := m.GetExtrema().(*ExtremaData_DoubleExtremaData); ok {
		return x.DoubleExtremaData
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ExtremaData) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ExtremaData_OneofMarshaler, _ExtremaData_OneofUnmarshaler, _ExtremaData_OneofSizer, []interface{}{
		(*ExtremaData_IntExtremaData)(nil),
		(*ExtremaData_DoubleExtremaData)(nil),
	}
}

func _ExtremaData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ExtremaData)
	// extrema
	switch x := m.Extrema.(type) {
	case *ExtremaData_IntExtremaData:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.IntExtremaData); err != nil {
			return err
		}
	case *ExtremaData_DoubleExtremaData:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DoubleExtremaData); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ExtremaData.Extrema has unexpected type %T", x)
	}
	return nil
}

func _ExtremaData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ExtremaData)
	switch tag {
	case 1: // extrema.int_extrema_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IntExtremaData)
		err := b.DecodeMessage(msg)
		m.Extrema = &ExtremaData_IntExtremaData{msg}
		return true, err
	case 2: // extrema.double_extrema_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DoubleExtremaData)
		err := b.DecodeMessage(msg)
		m.Extrema = &ExtremaData_DoubleExtremaData{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ExtremaData_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ExtremaData)
	// extrema
	switch x := m.Extrema.(type) {
	case *ExtremaData_IntExtremaData:
		s := proto.Size(x.IntExtremaData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ExtremaData_DoubleExtremaData:
		s := proto.Size(x.DoubleExtremaData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type IntExtremaData struct {
	IntValues            []int64  `protobuf:"varint,1,rep,packed,name=int_values,json=intValues,proto3" json:"int_values,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IntExtremaData proto.InternalMessageInfo

func (m *IntExtremaData) GetIntValues() []int64 {
	if m != nil {
		return m.IntValues
	}
	return nil
}

type DoubleExtremaData struct {
	DoubleValues         []float64 `protobuf:"fixed64,2,rep,packed,name=double_values,json=doubleValues,proto3" json:"double_values,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_DoubleExtremaData proto.InternalMessageInfo

func (m *DoubleExtremaData) GetDoubleValues() []float64 {
	if m != nil {
		return m.DoubleValues
	}
	return nil
}

// Data associated with a distribution metric.
// This is based off of the current DistributionData metric.
// This is not a stackdriver or dropwizard compatible
// style of distribution metric.
type DistributionData struct {
	// Types that are valid to be assigned to Distribution:
	//	*DistributionData_IntDistributionData
	//	*DistributionData_DoubleDistributionData
	Distribution         isDistributionData_Distribution `protobuf_oneof:"distribution"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_DistributionData proto.InternalMessageInfo

type isDistributionData_Distribution interface {
	isDistributionData_Distribution()
}

type DistributionData_IntDistributionData struct {
	IntDistributionData *IntDistributionData `protobuf:"bytes,1,opt,name=int_distribution_data,json=intDistributionData,proto3,oneof"`
}
type DistributionData_DoubleDistributionData struct {
	DoubleDistributionData *DoubleDistributionData `protobuf:"bytes,2,opt,name=double_distribution_data,json=doubleDistributionData,proto3,oneof"`
}

func (*DistributionData_IntDistributionData) isDistributionData_Distribution()    {}
func (*DistributionData_DoubleDistributionData) isDistributionData_Distribution() {}

func (m *DistributionData) GetDistribution() isDistributionData_Distribution {
	if m != nil {
		return m.Distribution
	}
	return nil
}

func (m *DistributionData) GetIntDistributionData() *IntDistributionData {
	if x, ok := m.GetDistribution().(*DistributionData_IntDistributionData); ok {
		return x.IntDistributionData
	}
	return nil
}

func (m *DistributionData) GetDoubleDistributionData() *DoubleDistributionData {
	if x, ok := m.GetDistribution().(*DistributionData_DoubleDistributionData); ok {
		return x.DoubleDistributionData
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*DistributionData) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _DistributionData_OneofMarshaler, _DistributionData_OneofUnmarshaler, _DistributionData_OneofSizer, []interface{}{
		(*DistributionData_IntDistributionData)(nil),
		(*DistributionData_DoubleDistributionData)(nil),
	}
}

func _DistributionData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*DistributionData)
	// distribution
	switch x := m.Distribution.(type) {
	case *DistributionData_IntDistributionData:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.IntDistributionData); err != nil {
			return err
		}
	case *DistributionData_DoubleDistributionData:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DoubleDistributionData); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("DistributionData.Distribution has unexpected type %T", x)
	}
	return nil
}

func _DistributionData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*DistributionData)
	switch tag {
	case 1: // distribution.int_distribution_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IntDistributionData)
		err := b.DecodeMessage(msg)
		m.Distribution = &DistributionData_IntDistributionData{msg}
		return true, err
	case 2: // distribution.double_distribution_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DoubleDistributionData)
		err := b.DecodeMessage(msg)
		m.Distribution = &DistributionData_DoubleDistributionData{msg}
		return true, err
	default:
		return false, nil
	}
}

func _DistributionData_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*DistributionData)
	// distribution
	switch x := m.Distribution.(type) {
	case *DistributionData_IntDistributionData:
		s := proto.Size(x.IntDistributionData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *DistributionData_DoubleDistributionData:
		s := proto.Size(x.DoubleDistributionData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type IntDistributionData struct {
	Count                int64    `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	Sum                  int64    `protobuf:"varint,2,opt,name=sum,proto3" json:"sum,omitempty"`
	Min                  int64    `protobuf:"varint,3,opt,name=min,proto3" json:"min,omitempty"`
	Max                  int64    `protobuf:"varint,4,opt,name=max,proto3" json:"max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IntDistributionData proto.InternalMessageInfo

func (m *IntDistributionData) GetCount() int64 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *IntDistributionData) GetSum() int64 {
	if m != nil {
		return m.Sum
	}
	return 0
}

func (m *IntDistributionData) GetMin() int64 {
	if m != nil {
		return m.Min
	}
	return 0
}

func (m *IntDistributionData) GetMax() int64 {
	if m != nil {
		return m.Max
	}
	return 0
}

type DoubleDistributionData struct {
	Count                int64    `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	Sum                  float64  `protobuf:"fixed64,2,opt,name=sum,proto3" json:"sum,omitempty"`
	Min                  float64  `protobuf:"fixed64,3,opt,name=min,proto3" json:"min,omitempty"`
	Max                  float64  `protobuf:"fixed64,4,opt,name=max,proto3" json:"max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DoubleDistributionData proto.InternalMessageInfo

func (m *DoubleDistributionData) GetCount() int64 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *DoubleDistributionData) GetSum() float64 {
	if m != nil {
		return m.Sum
	}
	return 0
}

func (m *DoubleDistributionData) GetMin() float64 {
	if m != nil {
		return m.Min
	}
	return 0
}

func (m *DoubleDistributionData) GetMax() float64 {
	if m != nil {
		return m.Max
	}
	return 0
}

// General MonitoredState information which contains
// structured information which does not fit into a typical
// metric format. For example, a table of important files
// and metadata which an I/O source is reading.
// Note: Since MonitoredState is designed to be
// customizable, and allow engines to aggregate these
// metrics in custom ways.
// Engines can use custom aggregation functions for specific URNs
// by inspecting the column values.
// An SDK should always report its current state, that is all
// relevant MonitoredState for its PTransform at the current moment
// and this should be kept small.
// For example, an SDK can emit the oldest three files which
// have been waiting for data for over 1 hour.
// If an engine supports the URN with a custom aggregation then
// it can filter these and keep only the Top-3 rows based on
// how long the files have been waiting for data.
// Otherwise an engine can ignore the MonitoringTableData
// or union all the rows together into one large table and display
// them in a UI.
type MonitoringTableData struct {
	// The number of column names must match the
	// number of values in each MonitoringRow.
	ColumnNames          []string                             `protobuf:"bytes,1,rep,name=column_names,json=columnNames,proto3" json:"column_names,omitempty"`
	RowData              []*MonitoringTableData_MonitoringRow `protobuf:"bytes,2,rep,name=row_data,json=rowData,proto3" json:"row_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

var xxx_messageInfo_MonitoringTableData proto.InternalMessageInfo

func (m *MonitoringTableData) GetColumnNames() []string {
	if m != nil {
		return m.ColumnNames
	}
	return nil
}

func (m *MonitoringTableData) GetRowData() []*MonitoringTableData_MonitoringRow {
	if m != nil {
		return m.RowData
	}
	return nil
}

type MonitoringTableData_MonitoringColumnValue struct {
	// Types that are valid to be assigned to Value:
	//	*MonitoringTableData_MonitoringColumnValue_Int64Value
	//	*MonitoringTableData_MonitoringColumnValue_DoubleValue
	//	*MonitoringTableData_MonitoringColumnValue_StringValue
	//	*MonitoringTableData_MonitoringColumnValue_Timestamp
	Value                isMonitoringTableData_MonitoringColumnValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}                                          `json:"-"`
	XXX_unrecognized     []byte                                            `json:"-"`
	XXX_sizecache        int32                                             `json:"-"`
}

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

var xxx_messageInfo_MonitoringTableData_MonitoringColumnValue proto.InternalMessageInfo

type isMonitoringTableData_MonitoringColumnValue_Value interface {
	isMonitoringTableData_MonitoringColumnValue_Value()
}

type MonitoringTableData_MonitoringColumnValue_Int64Value struct {
	Int64Value int64 `protobuf:"varint,1,opt,name=int64_value,json=int64Value,proto3,oneof"`
}
type MonitoringTableData_MonitoringColumnValue_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,2,opt,name=double_value,json=doubleValue,proto3,oneof"`
}
type MonitoringTableData_MonitoringColumnValue_StringValue struct {
	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}
type MonitoringTableData_MonitoringColumnValue_Timestamp struct {
	Timestamp *timestamp.Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3,oneof"`
}

func (*MonitoringTableData_MonitoringColumnValue_Int64Value) isMonitoringTableData_MonitoringColumnValue_Value() {
}
func (*MonitoringTableData_MonitoringColumnValue_DoubleValue) isMonitoringTableData_MonitoringColumnValue_Value() {
}
func (*MonitoringTableData_MonitoringColumnValue_StringValue) isMonitoringTableData_MonitoringColumnValue_Value() {
}
func (*MonitoringTableData_MonitoringColumnValue_Timestamp) isMonitoringTableData_MonitoringColumnValue_Value() {
}

func (m *MonitoringTableData_MonitoringColumnValue) GetValue() isMonitoringTableData_MonitoringColumnValue_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *MonitoringTableData_MonitoringColumnValue) GetInt64Value() int64 {
	if x, ok := m.GetValue().(*MonitoringTableData_MonitoringColumnValue_Int64Value); ok {
		return x.Int64Value
	}
	return 0
}

func (m *MonitoringTableData_MonitoringColumnValue) GetDoubleValue() float64 {
	if x, ok := m.GetValue().(*MonitoringTableData_MonitoringColumnValue_DoubleValue); ok {
		return x.DoubleValue
	}
	return 0
}

func (m *MonitoringTableData_MonitoringColumnValue) GetStringValue() string {
	if x, ok := m.GetValue().(*MonitoringTableData_MonitoringColumnValue_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *MonitoringTableData_MonitoringColumnValue) GetTimestamp() *timestamp.Timestamp {
	if x, ok := m.GetValue().(*MonitoringTableData_MonitoringColumnValue_Timestamp); ok {
		return x.Timestamp
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*MonitoringTableData_MonitoringColumnValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _MonitoringTableData_MonitoringColumnValue_OneofMarshaler, _MonitoringTableData_MonitoringColumnValue_OneofUnmarshaler, _MonitoringTableData_MonitoringColumnValue_OneofSizer, []interface{}{
		(*MonitoringTableData_MonitoringColumnValue_Int64Value)(nil),
		(*MonitoringTableData_MonitoringColumnValue_DoubleValue)(nil),
		(*MonitoringTableData_MonitoringColumnValue_StringValue)(nil),
		(*MonitoringTableData_MonitoringColumnValue_Timestamp)(nil),
	}
}

func _MonitoringTableData_MonitoringColumnValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*MonitoringTableData_MonitoringColumnValue)
	// value
	switch x := m.Value.(type) {
	case *MonitoringTableData_MonitoringColumnValue_Int64Value:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Int64Value))
	case *MonitoringTableData_MonitoringColumnValue_DoubleValue:
		b.EncodeVarint(2<<3 | proto.WireFixed64)
		b.EncodeFixed64(math.Float64bits(x.DoubleValue))
	case *MonitoringTableData_MonitoringColumnValue_StringValue:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.StringValue)
	case *MonitoringTableData_MonitoringColumnValue_Timestamp:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Timestamp); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("MonitoringTableData_MonitoringColumnValue.Value has unexpected type %T", x)
	}
	return nil
}

func _MonitoringTableData_MonitoringColumnValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*MonitoringTableData_MonitoringColumnValue)
	switch tag {
	case 1: // value.int64_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &MonitoringTableData_MonitoringColumnValue_Int64Value{int64(x)}
		return true, err
	case 2: // value.double_value
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.Value = &MonitoringTableData_MonitoringColumnValue_DoubleValue{math.Float64frombits(x)}
		return true, err
	case 3: // value.string_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &MonitoringTableData_MonitoringColumnValue_StringValue{x}
		return true, err
	case 4: // value.timestamp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(timestamp.Timestamp)
		err := b.DecodeMessage(msg)
		m.Value = &MonitoringTableData_MonitoringColumnValue_Timestamp{msg}
		return true, err
	default:
		return false, nil
	}
}

func _MonitoringTableData_MonitoringColumnValue_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*MonitoringTableData_MonitoringColumnValue)
	// value
	switch x := m.Value.(type) {
	case *MonitoringTableData_MonitoringColumnValue_Int64Value:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Int64Value))
	case *MonitoringTableData_MonitoringColumnValue_DoubleValue:
		n += 1 // tag and wire
		n += 8
	case *MonitoringTableData_MonitoringColumnValue_StringValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.StringValue)))
		n += len(x.StringValue)
	case *MonitoringTableData_MonitoringColumnValue_Timestamp:
		s := proto.Size(x.Timestamp)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type MonitoringTableData_MonitoringRow struct {
	Values               []*MonitoringTableData_MonitoringColumnValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}

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

var xxx_messageInfo_MonitoringTableData_MonitoringRow proto.InternalMessageInfo

func (m *MonitoringTableData_MonitoringRow) GetValues() []*MonitoringTableData_MonitoringColumnValue {
	if m != nil {
		return m.Values
	}
	return nil
}

var E_LabelProps = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
	ExtensionType: (*MonitoringInfoLabelProps)(nil),
	Field:         127337796,
	Name:          "org.apache.beam.model.pipeline.v1.label_props",
	Tag:           "bytes,127337796,opt,name=label_props,json=labelProps",
	Filename:      "metrics.proto",
}

var E_MonitoringInfoSpec = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
	ExtensionType: (*MonitoringInfoSpec)(nil),
	Field:         207174266,
	Name:          "org.apache.beam.model.pipeline.v1.monitoring_info_spec",
	Tag:           "bytes,207174266,opt,name=monitoring_info_spec,json=monitoringInfoSpec",
	Filename:      "metrics.proto",
}

func init() {
	proto.RegisterType((*MonitoringInfoSpec)(nil), "org.apache.beam.model.pipeline.v1.MonitoringInfoSpec")
	proto.RegisterType((*Annotation)(nil), "org.apache.beam.model.pipeline.v1.Annotation")
	proto.RegisterType((*MonitoringInfoSpecs)(nil), "org.apache.beam.model.pipeline.v1.MonitoringInfoSpecs")
	proto.RegisterType((*MonitoringInfoLabelProps)(nil), "org.apache.beam.model.pipeline.v1.MonitoringInfoLabelProps")
	proto.RegisterType((*MonitoringInfo)(nil), "org.apache.beam.model.pipeline.v1.MonitoringInfo")
	proto.RegisterMapType((map[string]string)(nil), "org.apache.beam.model.pipeline.v1.MonitoringInfo.LabelsEntry")
	proto.RegisterType((*MonitoringInfoTypeUrns)(nil), "org.apache.beam.model.pipeline.v1.MonitoringInfoTypeUrns")
	proto.RegisterType((*Metric)(nil), "org.apache.beam.model.pipeline.v1.Metric")
	proto.RegisterType((*CounterData)(nil), "org.apache.beam.model.pipeline.v1.CounterData")
	proto.RegisterType((*ExtremaData)(nil), "org.apache.beam.model.pipeline.v1.ExtremaData")
	proto.RegisterType((*IntExtremaData)(nil), "org.apache.beam.model.pipeline.v1.IntExtremaData")
	proto.RegisterType((*DoubleExtremaData)(nil), "org.apache.beam.model.pipeline.v1.DoubleExtremaData")
	proto.RegisterType((*DistributionData)(nil), "org.apache.beam.model.pipeline.v1.DistributionData")
	proto.RegisterType((*IntDistributionData)(nil), "org.apache.beam.model.pipeline.v1.IntDistributionData")
	proto.RegisterType((*DoubleDistributionData)(nil), "org.apache.beam.model.pipeline.v1.DoubleDistributionData")
	proto.RegisterType((*MonitoringTableData)(nil), "org.apache.beam.model.pipeline.v1.MonitoringTableData")
	proto.RegisterType((*MonitoringTableData_MonitoringColumnValue)(nil), "org.apache.beam.model.pipeline.v1.MonitoringTableData.MonitoringColumnValue")
	proto.RegisterType((*MonitoringTableData_MonitoringRow)(nil), "org.apache.beam.model.pipeline.v1.MonitoringTableData.MonitoringRow")
	proto.RegisterEnum("org.apache.beam.model.pipeline.v1.MonitoringInfoSpecs_Enum", MonitoringInfoSpecs_Enum_name, MonitoringInfoSpecs_Enum_value)
	proto.RegisterEnum("org.apache.beam.model.pipeline.v1.MonitoringInfo_MonitoringInfoLabels", MonitoringInfo_MonitoringInfoLabels_name, MonitoringInfo_MonitoringInfoLabels_value)
	proto.RegisterEnum("org.apache.beam.model.pipeline.v1.MonitoringInfoTypeUrns_Enum", MonitoringInfoTypeUrns_Enum_name, MonitoringInfoTypeUrns_Enum_value)
	proto.RegisterExtension(E_LabelProps)
	proto.RegisterExtension(E_MonitoringInfoSpec)
}

func init() { proto.RegisterFile("metrics.proto", fileDescriptor_metrics_f27e09e153e79ab4) }

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