// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/akuity/kargo/internal/controller/rollouts/api/v1alpha1/generated.proto

package v1alpha1

import (
	encoding_json "encoding/json"
	fmt "fmt"

	io "io"

	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"

	intstr "k8s.io/apimachinery/pkg/util/intstr"
)

// 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

func (m *AnalysisRun) Reset()      { *m = AnalysisRun{} }
func (*AnalysisRun) ProtoMessage() {}
func (*AnalysisRun) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{0}
}
func (m *AnalysisRun) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisRun) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRun.Merge(m, src)
}
func (m *AnalysisRun) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRun) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRun.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRun proto.InternalMessageInfo

func (m *AnalysisRunList) Reset()      { *m = AnalysisRunList{} }
func (*AnalysisRunList) ProtoMessage() {}
func (*AnalysisRunList) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{1}
}
func (m *AnalysisRunList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRunList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisRunList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRunList.Merge(m, src)
}
func (m *AnalysisRunList) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRunList) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRunList.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRunList proto.InternalMessageInfo

func (m *AnalysisRunSpec) Reset()      { *m = AnalysisRunSpec{} }
func (*AnalysisRunSpec) ProtoMessage() {}
func (*AnalysisRunSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{2}
}
func (m *AnalysisRunSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRunSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisRunSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRunSpec.Merge(m, src)
}
func (m *AnalysisRunSpec) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRunSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRunSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRunSpec proto.InternalMessageInfo

func (m *AnalysisRunStatus) Reset()      { *m = AnalysisRunStatus{} }
func (*AnalysisRunStatus) ProtoMessage() {}
func (*AnalysisRunStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{3}
}
func (m *AnalysisRunStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRunStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisRunStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRunStatus.Merge(m, src)
}
func (m *AnalysisRunStatus) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRunStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRunStatus.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRunStatus proto.InternalMessageInfo

func (m *AnalysisTemplate) Reset()      { *m = AnalysisTemplate{} }
func (*AnalysisTemplate) ProtoMessage() {}
func (*AnalysisTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{4}
}
func (m *AnalysisTemplate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisTemplate.Merge(m, src)
}
func (m *AnalysisTemplate) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisTemplate proto.InternalMessageInfo

func (m *AnalysisTemplateList) Reset()      { *m = AnalysisTemplateList{} }
func (*AnalysisTemplateList) ProtoMessage() {}
func (*AnalysisTemplateList) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{5}
}
func (m *AnalysisTemplateList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisTemplateList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisTemplateList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisTemplateList.Merge(m, src)
}
func (m *AnalysisTemplateList) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisTemplateList) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisTemplateList.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisTemplateList proto.InternalMessageInfo

func (m *AnalysisTemplateSpec) Reset()      { *m = AnalysisTemplateSpec{} }
func (*AnalysisTemplateSpec) ProtoMessage() {}
func (*AnalysisTemplateSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{6}
}
func (m *AnalysisTemplateSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisTemplateSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AnalysisTemplateSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisTemplateSpec.Merge(m, src)
}
func (m *AnalysisTemplateSpec) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisTemplateSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisTemplateSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisTemplateSpec proto.InternalMessageInfo

func (m *Argument) Reset()      { *m = Argument{} }
func (*Argument) ProtoMessage() {}
func (*Argument) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{7}
}
func (m *Argument) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Argument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Argument) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Argument.Merge(m, src)
}
func (m *Argument) XXX_Size() int {
	return m.Size()
}
func (m *Argument) XXX_DiscardUnknown() {
	xxx_messageInfo_Argument.DiscardUnknown(m)
}

var xxx_messageInfo_Argument proto.InternalMessageInfo

func (m *Authentication) Reset()      { *m = Authentication{} }
func (*Authentication) ProtoMessage() {}
func (*Authentication) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{8}
}
func (m *Authentication) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Authentication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Authentication) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Authentication.Merge(m, src)
}
func (m *Authentication) XXX_Size() int {
	return m.Size()
}
func (m *Authentication) XXX_DiscardUnknown() {
	xxx_messageInfo_Authentication.DiscardUnknown(m)
}

var xxx_messageInfo_Authentication proto.InternalMessageInfo

func (m *CloudWatchMetric) Reset()      { *m = CloudWatchMetric{} }
func (*CloudWatchMetric) ProtoMessage() {}
func (*CloudWatchMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{9}
}
func (m *CloudWatchMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudWatchMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudWatchMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudWatchMetric.Merge(m, src)
}
func (m *CloudWatchMetric) XXX_Size() int {
	return m.Size()
}
func (m *CloudWatchMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudWatchMetric.DiscardUnknown(m)
}

var xxx_messageInfo_CloudWatchMetric proto.InternalMessageInfo

func (m *CloudWatchMetricDataQuery) Reset()      { *m = CloudWatchMetricDataQuery{} }
func (*CloudWatchMetricDataQuery) ProtoMessage() {}
func (*CloudWatchMetricDataQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{10}
}
func (m *CloudWatchMetricDataQuery) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudWatchMetricDataQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudWatchMetricDataQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudWatchMetricDataQuery.Merge(m, src)
}
func (m *CloudWatchMetricDataQuery) XXX_Size() int {
	return m.Size()
}
func (m *CloudWatchMetricDataQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudWatchMetricDataQuery.DiscardUnknown(m)
}

var xxx_messageInfo_CloudWatchMetricDataQuery proto.InternalMessageInfo

func (m *CloudWatchMetricStat) Reset()      { *m = CloudWatchMetricStat{} }
func (*CloudWatchMetricStat) ProtoMessage() {}
func (*CloudWatchMetricStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{11}
}
func (m *CloudWatchMetricStat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudWatchMetricStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudWatchMetricStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudWatchMetricStat.Merge(m, src)
}
func (m *CloudWatchMetricStat) XXX_Size() int {
	return m.Size()
}
func (m *CloudWatchMetricStat) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudWatchMetricStat.DiscardUnknown(m)
}

var xxx_messageInfo_CloudWatchMetricStat proto.InternalMessageInfo

func (m *CloudWatchMetricStatMetric) Reset()      { *m = CloudWatchMetricStatMetric{} }
func (*CloudWatchMetricStatMetric) ProtoMessage() {}
func (*CloudWatchMetricStatMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{12}
}
func (m *CloudWatchMetricStatMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudWatchMetricStatMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudWatchMetricStatMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudWatchMetricStatMetric.Merge(m, src)
}
func (m *CloudWatchMetricStatMetric) XXX_Size() int {
	return m.Size()
}
func (m *CloudWatchMetricStatMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudWatchMetricStatMetric.DiscardUnknown(m)
}

var xxx_messageInfo_CloudWatchMetricStatMetric proto.InternalMessageInfo

func (m *CloudWatchMetricStatMetricDimension) Reset()      { *m = CloudWatchMetricStatMetricDimension{} }
func (*CloudWatchMetricStatMetricDimension) ProtoMessage() {}
func (*CloudWatchMetricStatMetricDimension) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{13}
}
func (m *CloudWatchMetricStatMetricDimension) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudWatchMetricStatMetricDimension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudWatchMetricStatMetricDimension) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudWatchMetricStatMetricDimension.Merge(m, src)
}
func (m *CloudWatchMetricStatMetricDimension) XXX_Size() int {
	return m.Size()
}
func (m *CloudWatchMetricStatMetricDimension) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudWatchMetricStatMetricDimension.DiscardUnknown(m)
}

var xxx_messageInfo_CloudWatchMetricStatMetricDimension proto.InternalMessageInfo

func (m *DatadogMetric) Reset()      { *m = DatadogMetric{} }
func (*DatadogMetric) ProtoMessage() {}
func (*DatadogMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{14}
}
func (m *DatadogMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DatadogMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DatadogMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DatadogMetric.Merge(m, src)
}
func (m *DatadogMetric) XXX_Size() int {
	return m.Size()
}
func (m *DatadogMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_DatadogMetric.DiscardUnknown(m)
}

var xxx_messageInfo_DatadogMetric proto.InternalMessageInfo

func (m *DryRun) Reset()      { *m = DryRun{} }
func (*DryRun) ProtoMessage() {}
func (*DryRun) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{15}
}
func (m *DryRun) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DryRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DryRun) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DryRun.Merge(m, src)
}
func (m *DryRun) XXX_Size() int {
	return m.Size()
}
func (m *DryRun) XXX_DiscardUnknown() {
	xxx_messageInfo_DryRun.DiscardUnknown(m)
}

var xxx_messageInfo_DryRun proto.InternalMessageInfo

func (m *FieldRef) Reset()      { *m = FieldRef{} }
func (*FieldRef) ProtoMessage() {}
func (*FieldRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{16}
}
func (m *FieldRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FieldRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *FieldRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldRef.Merge(m, src)
}
func (m *FieldRef) XXX_Size() int {
	return m.Size()
}
func (m *FieldRef) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldRef.DiscardUnknown(m)
}

var xxx_messageInfo_FieldRef proto.InternalMessageInfo

func (m *GraphiteMetric) Reset()      { *m = GraphiteMetric{} }
func (*GraphiteMetric) ProtoMessage() {}
func (*GraphiteMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{17}
}
func (m *GraphiteMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GraphiteMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *GraphiteMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GraphiteMetric.Merge(m, src)
}
func (m *GraphiteMetric) XXX_Size() int {
	return m.Size()
}
func (m *GraphiteMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_GraphiteMetric.DiscardUnknown(m)
}

var xxx_messageInfo_GraphiteMetric proto.InternalMessageInfo

func (m *InfluxdbMetric) Reset()      { *m = InfluxdbMetric{} }
func (*InfluxdbMetric) ProtoMessage() {}
func (*InfluxdbMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{18}
}
func (m *InfluxdbMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InfluxdbMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *InfluxdbMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InfluxdbMetric.Merge(m, src)
}
func (m *InfluxdbMetric) XXX_Size() int {
	return m.Size()
}
func (m *InfluxdbMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_InfluxdbMetric.DiscardUnknown(m)
}

var xxx_messageInfo_InfluxdbMetric proto.InternalMessageInfo

func (m *JobMetric) Reset()      { *m = JobMetric{} }
func (*JobMetric) ProtoMessage() {}
func (*JobMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{19}
}
func (m *JobMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *JobMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobMetric.Merge(m, src)
}
func (m *JobMetric) XXX_Size() int {
	return m.Size()
}
func (m *JobMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_JobMetric.DiscardUnknown(m)
}

var xxx_messageInfo_JobMetric proto.InternalMessageInfo

func (m *KayentaMetric) Reset()      { *m = KayentaMetric{} }
func (*KayentaMetric) ProtoMessage() {}
func (*KayentaMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{20}
}
func (m *KayentaMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KayentaMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KayentaMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KayentaMetric.Merge(m, src)
}
func (m *KayentaMetric) XXX_Size() int {
	return m.Size()
}
func (m *KayentaMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_KayentaMetric.DiscardUnknown(m)
}

var xxx_messageInfo_KayentaMetric proto.InternalMessageInfo

func (m *KayentaScope) Reset()      { *m = KayentaScope{} }
func (*KayentaScope) ProtoMessage() {}
func (*KayentaScope) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{21}
}
func (m *KayentaScope) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KayentaScope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KayentaScope) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KayentaScope.Merge(m, src)
}
func (m *KayentaScope) XXX_Size() int {
	return m.Size()
}
func (m *KayentaScope) XXX_DiscardUnknown() {
	xxx_messageInfo_KayentaScope.DiscardUnknown(m)
}

var xxx_messageInfo_KayentaScope proto.InternalMessageInfo

func (m *KayentaThreshold) Reset()      { *m = KayentaThreshold{} }
func (*KayentaThreshold) ProtoMessage() {}
func (*KayentaThreshold) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{22}
}
func (m *KayentaThreshold) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KayentaThreshold) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KayentaThreshold) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KayentaThreshold.Merge(m, src)
}
func (m *KayentaThreshold) XXX_Size() int {
	return m.Size()
}
func (m *KayentaThreshold) XXX_DiscardUnknown() {
	xxx_messageInfo_KayentaThreshold.DiscardUnknown(m)
}

var xxx_messageInfo_KayentaThreshold proto.InternalMessageInfo

func (m *Measurement) Reset()      { *m = Measurement{} }
func (*Measurement) ProtoMessage() {}
func (*Measurement) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{23}
}
func (m *Measurement) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Measurement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Measurement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Measurement.Merge(m, src)
}
func (m *Measurement) XXX_Size() int {
	return m.Size()
}
func (m *Measurement) XXX_DiscardUnknown() {
	xxx_messageInfo_Measurement.DiscardUnknown(m)
}

var xxx_messageInfo_Measurement proto.InternalMessageInfo

func (m *MeasurementRetention) Reset()      { *m = MeasurementRetention{} }
func (*MeasurementRetention) ProtoMessage() {}
func (*MeasurementRetention) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{24}
}
func (m *MeasurementRetention) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeasurementRetention) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MeasurementRetention) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeasurementRetention.Merge(m, src)
}
func (m *MeasurementRetention) XXX_Size() int {
	return m.Size()
}
func (m *MeasurementRetention) XXX_DiscardUnknown() {
	xxx_messageInfo_MeasurementRetention.DiscardUnknown(m)
}

var xxx_messageInfo_MeasurementRetention proto.InternalMessageInfo

func (m *Metric) Reset()      { *m = Metric{} }
func (*Metric) ProtoMessage() {}
func (*Metric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{25}
}
func (m *Metric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Metric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Metric.Merge(m, src)
}
func (m *Metric) XXX_Size() int {
	return m.Size()
}
func (m *Metric) XXX_DiscardUnknown() {
	xxx_messageInfo_Metric.DiscardUnknown(m)
}

var xxx_messageInfo_Metric proto.InternalMessageInfo

func (m *MetricProvider) Reset()      { *m = MetricProvider{} }
func (*MetricProvider) ProtoMessage() {}
func (*MetricProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{26}
}
func (m *MetricProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetricProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MetricProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricProvider.Merge(m, src)
}
func (m *MetricProvider) XXX_Size() int {
	return m.Size()
}
func (m *MetricProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricProvider.DiscardUnknown(m)
}

var xxx_messageInfo_MetricProvider proto.InternalMessageInfo

func (m *MetricResult) Reset()      { *m = MetricResult{} }
func (*MetricResult) ProtoMessage() {}
func (*MetricResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{27}
}
func (m *MetricResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetricResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MetricResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricResult.Merge(m, src)
}
func (m *MetricResult) XXX_Size() int {
	return m.Size()
}
func (m *MetricResult) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricResult.DiscardUnknown(m)
}

var xxx_messageInfo_MetricResult proto.InternalMessageInfo

func (m *NewRelicMetric) Reset()      { *m = NewRelicMetric{} }
func (*NewRelicMetric) ProtoMessage() {}
func (*NewRelicMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{28}
}
func (m *NewRelicMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NewRelicMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *NewRelicMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NewRelicMetric.Merge(m, src)
}
func (m *NewRelicMetric) XXX_Size() int {
	return m.Size()
}
func (m *NewRelicMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_NewRelicMetric.DiscardUnknown(m)
}

var xxx_messageInfo_NewRelicMetric proto.InternalMessageInfo

func (m *OAuth2Config) Reset()      { *m = OAuth2Config{} }
func (*OAuth2Config) ProtoMessage() {}
func (*OAuth2Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{29}
}
func (m *OAuth2Config) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OAuth2Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *OAuth2Config) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OAuth2Config.Merge(m, src)
}
func (m *OAuth2Config) XXX_Size() int {
	return m.Size()
}
func (m *OAuth2Config) XXX_DiscardUnknown() {
	xxx_messageInfo_OAuth2Config.DiscardUnknown(m)
}

var xxx_messageInfo_OAuth2Config proto.InternalMessageInfo

func (m *PrometheusMetric) Reset()      { *m = PrometheusMetric{} }
func (*PrometheusMetric) ProtoMessage() {}
func (*PrometheusMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{30}
}
func (m *PrometheusMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PrometheusMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *PrometheusMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrometheusMetric.Merge(m, src)
}
func (m *PrometheusMetric) XXX_Size() int {
	return m.Size()
}
func (m *PrometheusMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_PrometheusMetric.DiscardUnknown(m)
}

var xxx_messageInfo_PrometheusMetric proto.InternalMessageInfo

func (m *RunSummary) Reset()      { *m = RunSummary{} }
func (*RunSummary) ProtoMessage() {}
func (*RunSummary) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{31}
}
func (m *RunSummary) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RunSummary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *RunSummary) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunSummary.Merge(m, src)
}
func (m *RunSummary) XXX_Size() int {
	return m.Size()
}
func (m *RunSummary) XXX_DiscardUnknown() {
	xxx_messageInfo_RunSummary.DiscardUnknown(m)
}

var xxx_messageInfo_RunSummary proto.InternalMessageInfo

func (m *ScopeDetail) Reset()      { *m = ScopeDetail{} }
func (*ScopeDetail) ProtoMessage() {}
func (*ScopeDetail) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{32}
}
func (m *ScopeDetail) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScopeDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ScopeDetail) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScopeDetail.Merge(m, src)
}
func (m *ScopeDetail) XXX_Size() int {
	return m.Size()
}
func (m *ScopeDetail) XXX_DiscardUnknown() {
	xxx_messageInfo_ScopeDetail.DiscardUnknown(m)
}

var xxx_messageInfo_ScopeDetail proto.InternalMessageInfo

func (m *SecretKeyRef) Reset()      { *m = SecretKeyRef{} }
func (*SecretKeyRef) ProtoMessage() {}
func (*SecretKeyRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{33}
}
func (m *SecretKeyRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SecretKeyRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SecretKeyRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SecretKeyRef.Merge(m, src)
}
func (m *SecretKeyRef) XXX_Size() int {
	return m.Size()
}
func (m *SecretKeyRef) XXX_DiscardUnknown() {
	xxx_messageInfo_SecretKeyRef.DiscardUnknown(m)
}

var xxx_messageInfo_SecretKeyRef proto.InternalMessageInfo

func (m *Sigv4Config) Reset()      { *m = Sigv4Config{} }
func (*Sigv4Config) ProtoMessage() {}
func (*Sigv4Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{34}
}
func (m *Sigv4Config) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Sigv4Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Sigv4Config) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Sigv4Config.Merge(m, src)
}
func (m *Sigv4Config) XXX_Size() int {
	return m.Size()
}
func (m *Sigv4Config) XXX_DiscardUnknown() {
	xxx_messageInfo_Sigv4Config.DiscardUnknown(m)
}

var xxx_messageInfo_Sigv4Config proto.InternalMessageInfo

func (m *SkyWalkingMetric) Reset()      { *m = SkyWalkingMetric{} }
func (*SkyWalkingMetric) ProtoMessage() {}
func (*SkyWalkingMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{35}
}
func (m *SkyWalkingMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SkyWalkingMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SkyWalkingMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SkyWalkingMetric.Merge(m, src)
}
func (m *SkyWalkingMetric) XXX_Size() int {
	return m.Size()
}
func (m *SkyWalkingMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_SkyWalkingMetric.DiscardUnknown(m)
}

var xxx_messageInfo_SkyWalkingMetric proto.InternalMessageInfo

func (m *ValueFrom) Reset()      { *m = ValueFrom{} }
func (*ValueFrom) ProtoMessage() {}
func (*ValueFrom) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{36}
}
func (m *ValueFrom) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValueFrom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ValueFrom) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValueFrom.Merge(m, src)
}
func (m *ValueFrom) XXX_Size() int {
	return m.Size()
}
func (m *ValueFrom) XXX_DiscardUnknown() {
	xxx_messageInfo_ValueFrom.DiscardUnknown(m)
}

var xxx_messageInfo_ValueFrom proto.InternalMessageInfo

func (m *WavefrontMetric) Reset()      { *m = WavefrontMetric{} }
func (*WavefrontMetric) ProtoMessage() {}
func (*WavefrontMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{37}
}
func (m *WavefrontMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WavefrontMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WavefrontMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WavefrontMetric.Merge(m, src)
}
func (m *WavefrontMetric) XXX_Size() int {
	return m.Size()
}
func (m *WavefrontMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_WavefrontMetric.DiscardUnknown(m)
}

var xxx_messageInfo_WavefrontMetric proto.InternalMessageInfo

func (m *WebMetric) Reset()      { *m = WebMetric{} }
func (*WebMetric) ProtoMessage() {}
func (*WebMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{38}
}
func (m *WebMetric) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WebMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WebMetric) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WebMetric.Merge(m, src)
}
func (m *WebMetric) XXX_Size() int {
	return m.Size()
}
func (m *WebMetric) XXX_DiscardUnknown() {
	xxx_messageInfo_WebMetric.DiscardUnknown(m)
}

var xxx_messageInfo_WebMetric proto.InternalMessageInfo

func (m *WebMetricHeader) Reset()      { *m = WebMetricHeader{} }
func (*WebMetricHeader) ProtoMessage() {}
func (*WebMetricHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5bdcafc2831c0b4, []int{39}
}
func (m *WebMetricHeader) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WebMetricHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WebMetricHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WebMetricHeader.Merge(m, src)
}
func (m *WebMetricHeader) XXX_Size() int {
	return m.Size()
}
func (m *WebMetricHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_WebMetricHeader.DiscardUnknown(m)
}

var xxx_messageInfo_WebMetricHeader proto.InternalMessageInfo

func init() {
	proto.RegisterType((*AnalysisRun)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisRun")
	proto.RegisterType((*AnalysisRunList)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisRunList")
	proto.RegisterType((*AnalysisRunSpec)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisRunSpec")
	proto.RegisterType((*AnalysisRunStatus)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisRunStatus")
	proto.RegisterType((*AnalysisTemplate)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisTemplate")
	proto.RegisterType((*AnalysisTemplateList)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisTemplateList")
	proto.RegisterType((*AnalysisTemplateSpec)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisTemplateSpec")
	proto.RegisterType((*Argument)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.Argument")
	proto.RegisterType((*Authentication)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.Authentication")
	proto.RegisterType((*CloudWatchMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.CloudWatchMetric")
	proto.RegisterType((*CloudWatchMetricDataQuery)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.CloudWatchMetricDataQuery")
	proto.RegisterType((*CloudWatchMetricStat)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.CloudWatchMetricStat")
	proto.RegisterType((*CloudWatchMetricStatMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.CloudWatchMetricStatMetric")
	proto.RegisterType((*CloudWatchMetricStatMetricDimension)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.CloudWatchMetricStatMetricDimension")
	proto.RegisterType((*DatadogMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.DatadogMetric")
	proto.RegisterMapType((map[string]string)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.DatadogMetric.QueriesEntry")
	proto.RegisterType((*DryRun)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.DryRun")
	proto.RegisterType((*FieldRef)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.FieldRef")
	proto.RegisterType((*GraphiteMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.GraphiteMetric")
	proto.RegisterType((*InfluxdbMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.InfluxdbMetric")
	proto.RegisterType((*JobMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.JobMetric")
	proto.RegisterType((*KayentaMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.KayentaMetric")
	proto.RegisterType((*KayentaScope)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.KayentaScope")
	proto.RegisterType((*KayentaThreshold)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.KayentaThreshold")
	proto.RegisterType((*Measurement)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.Measurement")
	proto.RegisterMapType((map[string]string)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.Measurement.MetadataEntry")
	proto.RegisterType((*MeasurementRetention)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.MeasurementRetention")
	proto.RegisterType((*Metric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.Metric")
	proto.RegisterType((*MetricProvider)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.MetricProvider")
	proto.RegisterMapType((map[string]encoding_json.RawMessage)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.MetricProvider.PluginEntry")
	proto.RegisterType((*MetricResult)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.MetricResult")
	proto.RegisterMapType((map[string]string)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.MetricResult.MetadataEntry")
	proto.RegisterType((*NewRelicMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.NewRelicMetric")
	proto.RegisterType((*OAuth2Config)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.OAuth2Config")
	proto.RegisterType((*PrometheusMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.PrometheusMetric")
	proto.RegisterType((*RunSummary)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.RunSummary")
	proto.RegisterType((*ScopeDetail)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.ScopeDetail")
	proto.RegisterType((*SecretKeyRef)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.SecretKeyRef")
	proto.RegisterType((*Sigv4Config)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.Sigv4Config")
	proto.RegisterType((*SkyWalkingMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.SkyWalkingMetric")
	proto.RegisterType((*ValueFrom)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.ValueFrom")
	proto.RegisterType((*WavefrontMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.WavefrontMetric")
	proto.RegisterType((*WebMetric)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.WebMetric")
	proto.RegisterType((*WebMetricHeader)(nil), "github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.WebMetricHeader")
}

func init() {
	proto.RegisterFile("github.com/akuity/kargo/internal/controller/rollouts/api/v1alpha1/generated.proto", fileDescriptor_c5bdcafc2831c0b4)
}

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

func (m *AnalysisRun) 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 *AnalysisRun) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisRun) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *AnalysisRunList) 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 *AnalysisRunList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisRunList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *AnalysisRunSpec) 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 *AnalysisRunSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisRunSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MeasurementRetention) > 0 {
		for iNdEx := len(m.MeasurementRetention) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MeasurementRetention[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.DryRun) > 0 {
		for iNdEx := len(m.DryRun) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DryRun[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	i--
	if m.Terminate {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Metrics) > 0 {
		for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AnalysisRunStatus) 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 *AnalysisRunStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisRunStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DryRunSummary != nil {
		{
			size, err := m.DryRunSummary.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	{
		size, err := m.RunSummary.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.StartedAt != nil {
		{
			size, err := m.StartedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.MetricResults) > 0 {
		for iNdEx := len(m.MetricResults) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MetricResults[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *AnalysisTemplate) 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 *AnalysisTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *AnalysisTemplateList) 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 *AnalysisTemplateList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisTemplateList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *AnalysisTemplateSpec) 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 *AnalysisTemplateSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisTemplateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MeasurementRetention) > 0 {
		for iNdEx := len(m.MeasurementRetention) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MeasurementRetention[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.DryRun) > 0 {
		for iNdEx := len(m.DryRun) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DryRun[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Metrics) > 0 {
		for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Argument) 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 *Argument) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Argument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ValueFrom != nil {
		{
			size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Value != nil {
		i -= len(*m.Value)
		copy(dAtA[i:], *m.Value)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Value)))
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Authentication) 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 *Authentication) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Authentication) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.OAuth2.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Sigv4.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CloudWatchMetric) 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 *CloudWatchMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloudWatchMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MetricDataQueries) > 0 {
		for iNdEx := len(m.MetricDataQueries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MetricDataQueries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	i -= len(m.Interval)
	copy(dAtA[i:], m.Interval)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CloudWatchMetricDataQuery) 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 *CloudWatchMetricDataQuery) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloudWatchMetricDataQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReturnData != nil {
		i--
		if *m.ReturnData {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Period != nil {
		{
			size, err := m.Period.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.MetricStat != nil {
		{
			size, err := m.MetricStat.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Label != nil {
		i -= len(*m.Label)
		copy(dAtA[i:], *m.Label)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Label)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Expression != nil {
		i -= len(*m.Expression)
		copy(dAtA[i:], *m.Expression)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Expression)))
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Id)
	copy(dAtA[i:], m.Id)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Id)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CloudWatchMetricStat) 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 *CloudWatchMetricStat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloudWatchMetricStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Unit)
	copy(dAtA[i:], m.Unit)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Unit)))
	i--
	dAtA[i] = 0x22
	i -= len(m.Stat)
	copy(dAtA[i:], m.Stat)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Stat)))
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Period.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CloudWatchMetricStatMetric) 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 *CloudWatchMetricStatMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloudWatchMetricStatMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Namespace != nil {
		i -= len(*m.Namespace)
		copy(dAtA[i:], *m.Namespace)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Namespace)))
		i--
		dAtA[i] = 0x1a
	}
	i -= len(m.MetricName)
	copy(dAtA[i:], m.MetricName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
	i--
	dAtA[i] = 0x12
	if len(m.Dimensions) > 0 {
		for iNdEx := len(m.Dimensions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Dimensions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CloudWatchMetricStatMetricDimension) 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 *CloudWatchMetricStatMetricDimension) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloudWatchMetricStatMetricDimension) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Value)
	copy(dAtA[i:], m.Value)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *DatadogMetric) 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 *DatadogMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DatadogMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.ApiVersion)
	copy(dAtA[i:], m.ApiVersion)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ApiVersion)))
	i--
	dAtA[i] = 0x2a
	i -= len(m.Formula)
	copy(dAtA[i:], m.Formula)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Formula)))
	i--
	dAtA[i] = 0x22
	if len(m.Queries) > 0 {
		keysForQueries := make([]string, 0, len(m.Queries))
		for k := range m.Queries {
			keysForQueries = append(keysForQueries, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForQueries)
		for iNdEx := len(keysForQueries) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Queries[string(keysForQueries[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForQueries[iNdEx])
			copy(dAtA[i:], keysForQueries[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForQueries[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Interval)
	copy(dAtA[i:], m.Interval)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *DryRun) 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 *DryRun) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DryRun) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.MetricName)
	copy(dAtA[i:], m.MetricName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *FieldRef) 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 *FieldRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FieldRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.FieldPath)
	copy(dAtA[i:], m.FieldPath)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldPath)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *GraphiteMetric) 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 *GraphiteMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GraphiteMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Address)
	copy(dAtA[i:], m.Address)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *InfluxdbMetric) 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 *InfluxdbMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InfluxdbMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Profile)
	copy(dAtA[i:], m.Profile)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Profile)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *JobMetric) 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 *JobMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *KayentaMetric) 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 *KayentaMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KayentaMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scopes) > 0 {
		for iNdEx := len(m.Scopes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Scopes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	{
		size, err := m.Threshold.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	i -= len(m.StorageAccountName)
	copy(dAtA[i:], m.StorageAccountName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StorageAccountName)))
	i--
	dAtA[i] = 0x32
	i -= len(m.ConfigurationAccountName)
	copy(dAtA[i:], m.ConfigurationAccountName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ConfigurationAccountName)))
	i--
	dAtA[i] = 0x2a
	i -= len(m.MetricsAccountName)
	copy(dAtA[i:], m.MetricsAccountName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricsAccountName)))
	i--
	dAtA[i] = 0x22
	i -= len(m.CanaryConfigName)
	copy(dAtA[i:], m.CanaryConfigName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CanaryConfigName)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Application)
	copy(dAtA[i:], m.Application)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Application)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Address)
	copy(dAtA[i:], m.Address)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *KayentaScope) 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 *KayentaScope) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KayentaScope) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExperimentScope.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.ControlScope.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *KayentaThreshold) 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 *KayentaThreshold) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KayentaThreshold) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.Marginal))
	i--
	dAtA[i] = 0x10
	i = encodeVarintGenerated(dAtA, i, uint64(m.Pass))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

func (m *Measurement) 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 *Measurement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Measurement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ResumeAt != nil {
		{
			size, err := m.ResumeAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Metadata) > 0 {
		keysForMetadata := make([]string, 0, len(m.Metadata))
		for k := range m.Metadata {
			keysForMetadata = append(keysForMetadata, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
		for iNdEx := len(keysForMetadata) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Metadata[string(keysForMetadata[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForMetadata[iNdEx])
			copy(dAtA[i:], keysForMetadata[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetadata[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	i -= len(m.Value)
	copy(dAtA[i:], m.Value)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
	i--
	dAtA[i] = 0x2a
	if m.FinishedAt != nil {
		{
			size, err := m.FinishedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.StartedAt != nil {
		{
			size, err := m.StartedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *MeasurementRetention) 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 *MeasurementRetention) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeasurementRetention) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.Limit))
	i--
	dAtA[i] = 0x10
	i -= len(m.MetricName)
	copy(dAtA[i:], m.MetricName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Metric) 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 *Metric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Provider.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	if m.ConsecutiveErrorLimit != nil {
		{
			size, err := m.ConsecutiveErrorLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.InconclusiveLimit != nil {
		{
			size, err := m.InconclusiveLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.FailureLimit != nil {
		{
			size, err := m.FailureLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	i -= len(m.FailureCondition)
	copy(dAtA[i:], m.FailureCondition)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FailureCondition)))
	i--
	dAtA[i] = 0x32
	i -= len(m.SuccessCondition)
	copy(dAtA[i:], m.SuccessCondition)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SuccessCondition)))
	i--
	dAtA[i] = 0x2a
	if m.Count != nil {
		{
			size, err := m.Count.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	i -= len(m.InitialDelay)
	copy(dAtA[i:], m.InitialDelay)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.InitialDelay)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Interval)
	copy(dAtA[i:], m.Interval)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *MetricProvider) 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 *MetricProvider) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetricProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Plugin) > 0 {
		keysForPlugin := make([]string, 0, len(m.Plugin))
		for k := range m.Plugin {
			keysForPlugin = append(keysForPlugin, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForPlugin)
		for iNdEx := len(keysForPlugin) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Plugin[string(keysForPlugin[iNdEx])]
			baseI := i
			if v != nil {
				i -= len(v)
				copy(dAtA[i:], v)
				i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
				i--
				dAtA[i] = 0x12
			}
			i -= len(keysForPlugin[iNdEx])
			copy(dAtA[i:], keysForPlugin[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPlugin[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	if m.SkyWalking != nil {
		{
			size, err := m.SkyWalking.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.Influxdb != nil {
		{
			size, err := m.Influxdb.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.Graphite != nil {
		{
			size, err := m.Graphite.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.CloudWatch != nil {
		{
			size, err := m.CloudWatch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Job != nil {
		{
			size, err := m.Job.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.NewRelic != nil {
		{
			size, err := m.NewRelic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Wavefront != nil {
		{
			size, err := m.Wavefront.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Datadog != nil {
		{
			size, err := m.Datadog.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Web != nil {
		{
			size, err := m.Web.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Kayenta != nil {
		{
			size, err := m.Kayenta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Prometheus != nil {
		{
			size, err := m.Prometheus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MetricResult) 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 *MetricResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetricResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Metadata) > 0 {
		keysForMetadata := make([]string, 0, len(m.Metadata))
		for k := range m.Metadata {
			keysForMetadata = append(keysForMetadata, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
		for iNdEx := len(keysForMetadata) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Metadata[string(keysForMetadata[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForMetadata[iNdEx])
			copy(dAtA[i:], keysForMetadata[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetadata[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	i--
	if m.DryRun {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x58
	i = encodeVarintGenerated(dAtA, i, uint64(m.ConsecutiveError))
	i--
	dAtA[i] = 0x50
	i = encodeVarintGenerated(dAtA, i, uint64(m.Error))
	i--
	dAtA[i] = 0x48
	i = encodeVarintGenerated(dAtA, i, uint64(m.Inconclusive))
	i--
	dAtA[i] = 0x40
	i = encodeVarintGenerated(dAtA, i, uint64(m.Failed))
	i--
	dAtA[i] = 0x38
	i = encodeVarintGenerated(dAtA, i, uint64(m.Successful))
	i--
	dAtA[i] = 0x30
	i = encodeVarintGenerated(dAtA, i, uint64(m.Count))
	i--
	dAtA[i] = 0x28
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x22
	if len(m.Measurements) > 0 {
		for iNdEx := len(m.Measurements) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Measurements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *NewRelicMetric) 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 *NewRelicMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NewRelicMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Profile)
	copy(dAtA[i:], m.Profile)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Profile)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *OAuth2Config) 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 *OAuth2Config) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OAuth2Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scopes) > 0 {
		for iNdEx := len(m.Scopes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Scopes[iNdEx])
			copy(dAtA[i:], m.Scopes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scopes[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	i -= len(m.ClientSecret)
	copy(dAtA[i:], m.ClientSecret)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientSecret)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.ClientID)
	copy(dAtA[i:], m.ClientID)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientID)))
	i--
	dAtA[i] = 0x12
	i -= len(m.TokenURL)
	copy(dAtA[i:], m.TokenURL)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TokenURL)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *PrometheusMetric) 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 *PrometheusMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PrometheusMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Headers) > 0 {
		for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	i--
	if m.Insecure {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x28
	if m.Timeout != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Timeout))
		i--
		dAtA[i] = 0x20
	}
	{
		size, err := m.Authentication.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Address)
	copy(dAtA[i:], m.Address)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *RunSummary) 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 *RunSummary) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RunSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.Error))
	i--
	dAtA[i] = 0x28
	i = encodeVarintGenerated(dAtA, i, uint64(m.Inconclusive))
	i--
	dAtA[i] = 0x20
	i = encodeVarintGenerated(dAtA, i, uint64(m.Failed))
	i--
	dAtA[i] = 0x18
	i = encodeVarintGenerated(dAtA, i, uint64(m.Successful))
	i--
	dAtA[i] = 0x10
	i = encodeVarintGenerated(dAtA, i, uint64(m.Count))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

func (m *ScopeDetail) 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 *ScopeDetail) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScopeDetail) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.End)
	copy(dAtA[i:], m.End)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.End)))
	i--
	dAtA[i] = 0x2a
	i -= len(m.Start)
	copy(dAtA[i:], m.Start)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Start)))
	i--
	dAtA[i] = 0x22
	i = encodeVarintGenerated(dAtA, i, uint64(m.Step))
	i--
	dAtA[i] = 0x18
	i -= len(m.Region)
	copy(dAtA[i:], m.Region)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Scope)
	copy(dAtA[i:], m.Scope)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scope)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *SecretKeyRef) 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 *SecretKeyRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SecretKeyRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Key)
	copy(dAtA[i:], m.Key)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Sigv4Config) 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 *Sigv4Config) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Sigv4Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.RoleARN)
	copy(dAtA[i:], m.RoleARN)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RoleARN)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Profile)
	copy(dAtA[i:], m.Profile)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Profile)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Region)
	copy(dAtA[i:], m.Region)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *SkyWalkingMetric) 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 *SkyWalkingMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SkyWalkingMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Interval)
	copy(dAtA[i:], m.Interval)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Address)
	copy(dAtA[i:], m.Address)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ValueFrom) 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 *ValueFrom) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FieldRef != nil {
		{
			size, err := m.FieldRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.SecretKeyRef != nil {
		{
			size, err := m.SecretKeyRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WavefrontMetric) 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 *WavefrontMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WavefrontMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Query)
	copy(dAtA[i:], m.Query)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Address)
	copy(dAtA[i:], m.Address)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *WebMetric) 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 *WebMetric) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WebMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Authentication.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if m.JSONBody != nil {
		i -= len(m.JSONBody)
		copy(dAtA[i:], m.JSONBody)
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONBody)))
		i--
		dAtA[i] = 0x42
	}
	i--
	if m.Insecure {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x38
	i -= len(m.JSONPath)
	copy(dAtA[i:], m.JSONPath)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONPath)))
	i--
	dAtA[i] = 0x32
	i = encodeVarintGenerated(dAtA, i, uint64(m.TimeoutSeconds))
	i--
	dAtA[i] = 0x28
	i -= len(m.Body)
	copy(dAtA[i:], m.Body)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Body)))
	i--
	dAtA[i] = 0x22
	if len(m.Headers) > 0 {
		for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	i -= len(m.URL)
	copy(dAtA[i:], m.URL)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Method)
	copy(dAtA[i:], m.Method)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Method)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *WebMetricHeader) 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 *WebMetricHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WebMetricHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Value)
	copy(dAtA[i:], m.Value)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Key)
	copy(dAtA[i:], m.Key)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenerated(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *AnalysisRun) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *AnalysisRunList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ListMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *AnalysisRunSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Metrics) > 0 {
		for _, e := range m.Metrics {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	n += 2
	if len(m.DryRun) > 0 {
		for _, e := range m.DryRun {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.MeasurementRetention) > 0 {
		for _, e := range m.MeasurementRetention {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *AnalysisRunStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Phase)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.MetricResults) > 0 {
		for _, e := range m.MetricResults {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.StartedAt != nil {
		l = m.StartedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.RunSummary.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.DryRunSummary != nil {
		l = m.DryRunSummary.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *AnalysisTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *AnalysisTemplateList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ListMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *AnalysisTemplateSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Metrics) > 0 {
		for _, e := range m.Metrics {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.DryRun) > 0 {
		for _, e := range m.DryRun {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.MeasurementRetention) > 0 {
		for _, e := range m.MeasurementRetention {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *Argument) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Value != nil {
		l = len(*m.Value)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ValueFrom != nil {
		l = m.ValueFrom.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Authentication) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Sigv4.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.OAuth2.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *CloudWatchMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Interval)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.MetricDataQueries) > 0 {
		for _, e := range m.MetricDataQueries {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *CloudWatchMetricDataQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Expression != nil {
		l = len(*m.Expression)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Label != nil {
		l = len(*m.Label)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MetricStat != nil {
		l = m.MetricStat.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Period != nil {
		l = m.Period.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ReturnData != nil {
		n += 2
	}
	return n
}

func (m *CloudWatchMetricStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Metric.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Period.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Stat)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Unit)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *CloudWatchMetricStatMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Dimensions) > 0 {
		for _, e := range m.Dimensions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = len(m.MetricName)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Namespace != nil {
		l = len(*m.Namespace)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *CloudWatchMetricStatMetricDimension) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Value)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *DatadogMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Interval)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Queries) > 0 {
		for k, v := range m.Queries {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	l = len(m.Formula)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.ApiVersion)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *DryRun) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MetricName)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *FieldRef) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FieldPath)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *GraphiteMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *InfluxdbMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Profile)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *JobMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Metadata.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *KayentaMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Application)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.CanaryConfigName)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.MetricsAccountName)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.ConfigurationAccountName)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.StorageAccountName)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Threshold.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Scopes) > 0 {
		for _, e := range m.Scopes {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *KayentaScope) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.ControlScope.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.ExperimentScope.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *KayentaThreshold) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.Pass))
	n += 1 + sovGenerated(uint64(m.Marginal))
	return n
}

func (m *Measurement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Phase)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	if m.StartedAt != nil {
		l = m.StartedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.FinishedAt != nil {
		l = m.FinishedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Value)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Metadata) > 0 {
		for k, v := range m.Metadata {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if m.ResumeAt != nil {
		l = m.ResumeAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *MeasurementRetention) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MetricName)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Limit))
	return n
}

func (m *Metric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Interval)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.InitialDelay)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Count != nil {
		l = m.Count.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.SuccessCondition)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.FailureCondition)
	n += 1 + l + sovGenerated(uint64(l))
	if m.FailureLimit != nil {
		l = m.FailureLimit.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.InconclusiveLimit != nil {
		l = m.InconclusiveLimit.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ConsecutiveErrorLimit != nil {
		l = m.ConsecutiveErrorLimit.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Provider.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *MetricProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Prometheus != nil {
		l = m.Prometheus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Kayenta != nil {
		l = m.Kayenta.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Web != nil {
		l = m.Web.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Datadog != nil {
		l = m.Datadog.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Wavefront != nil {
		l = m.Wavefront.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NewRelic != nil {
		l = m.NewRelic.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Job != nil {
		l = m.Job.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.CloudWatch != nil {
		l = m.CloudWatch.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Graphite != nil {
		l = m.Graphite.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Influxdb != nil {
		l = m.Influxdb.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SkyWalking != nil {
		l = m.SkyWalking.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Plugin) > 0 {
		for k, v := range m.Plugin {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = 1 + len(v) + sovGenerated(uint64(len(v)))
			}
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *MetricResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Phase)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Measurements) > 0 {
		for _, e := range m.Measurements {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Count))
	n += 1 + sovGenerated(uint64(m.Successful))
	n += 1 + sovGenerated(uint64(m.Failed))
	n += 1 + sovGenerated(uint64(m.Inconclusive))
	n += 1 + sovGenerated(uint64(m.Error))
	n += 1 + sovGenerated(uint64(m.ConsecutiveError))
	n += 2
	if len(m.Metadata) > 0 {
		for k, v := range m.Metadata {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *NewRelicMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Profile)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *OAuth2Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TokenURL)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.ClientID)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.ClientSecret)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Scopes) > 0 {
		for _, s := range m.Scopes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *PrometheusMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Authentication.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Timeout != nil {
		n += 1 + sovGenerated(uint64(*m.Timeout))
	}
	n += 2
	if len(m.Headers) > 0 {
		for _, e := range m.Headers {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *RunSummary) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.Count))
	n += 1 + sovGenerated(uint64(m.Successful))
	n += 1 + sovGenerated(uint64(m.Failed))
	n += 1 + sovGenerated(uint64(m.Inconclusive))
	n += 1 + sovGenerated(uint64(m.Error))
	return n
}

func (m *ScopeDetail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Scope)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Region)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Step))
	l = len(m.Start)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.End)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *SecretKeyRef) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Key)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Sigv4Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Region)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Profile)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.RoleARN)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *SkyWalkingMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Interval)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ValueFrom) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SecretKeyRef != nil {
		l = m.SecretKeyRef.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.FieldRef != nil {
		l = m.FieldRef.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *WavefrontMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Query)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *WebMetric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Method)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.URL)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Headers) > 0 {
		for _, e := range m.Headers {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = len(m.Body)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.TimeoutSeconds))
	l = len(m.JSONPath)
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	if m.JSONBody != nil {
		l = len(m.JSONBody)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Authentication.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *WebMetricHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Value)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func sovGenerated(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenerated(x uint64) (n int) {
	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *AnalysisRun) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AnalysisRun{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "AnalysisRunSpec", "AnalysisRunSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "AnalysisRunStatus", "AnalysisRunStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisRunList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]AnalysisRun{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "AnalysisRun", "AnalysisRun", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&AnalysisRunList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisRunSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMetrics := "[]Metric{"
	for _, f := range this.Metrics {
		repeatedStringForMetrics += strings.Replace(strings.Replace(f.String(), "Metric", "Metric", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMetrics += "}"
	repeatedStringForArgs := "[]Argument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "Argument", "Argument", 1), `&`, ``, 1) + ","
	}
	repeatedStringForArgs += "}"
	repeatedStringForDryRun := "[]DryRun{"
	for _, f := range this.DryRun {
		repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + ","
	}
	repeatedStringForDryRun += "}"
	repeatedStringForMeasurementRetention := "[]MeasurementRetention{"
	for _, f := range this.MeasurementRetention {
		repeatedStringForMeasurementRetention += strings.Replace(strings.Replace(f.String(), "MeasurementRetention", "MeasurementRetention", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMeasurementRetention += "}"
	s := strings.Join([]string{`&AnalysisRunSpec{`,
		`Metrics:` + repeatedStringForMetrics + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`Terminate:` + fmt.Sprintf("%v", this.Terminate) + `,`,
		`DryRun:` + repeatedStringForDryRun + `,`,
		`MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisRunStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMetricResults := "[]MetricResult{"
	for _, f := range this.MetricResults {
		repeatedStringForMetricResults += strings.Replace(strings.Replace(f.String(), "MetricResult", "MetricResult", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMetricResults += "}"
	s := strings.Join([]string{`&AnalysisRunStatus{`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`MetricResults:` + repeatedStringForMetricResults + `,`,
		`StartedAt:` + strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Time", "v1.Time", 1) + `,`,
		`RunSummary:` + strings.Replace(strings.Replace(this.RunSummary.String(), "RunSummary", "RunSummary", 1), `&`, ``, 1) + `,`,
		`DryRunSummary:` + strings.Replace(this.DryRunSummary.String(), "RunSummary", "RunSummary", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisTemplate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AnalysisTemplate{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "AnalysisTemplateSpec", "AnalysisTemplateSpec", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisTemplateList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]AnalysisTemplate{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "AnalysisTemplate", "AnalysisTemplate", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&AnalysisTemplateList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisTemplateSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMetrics := "[]Metric{"
	for _, f := range this.Metrics {
		repeatedStringForMetrics += strings.Replace(strings.Replace(f.String(), "Metric", "Metric", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMetrics += "}"
	repeatedStringForArgs := "[]Argument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "Argument", "Argument", 1), `&`, ``, 1) + ","
	}
	repeatedStringForArgs += "}"
	repeatedStringForDryRun := "[]DryRun{"
	for _, f := range this.DryRun {
		repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + ","
	}
	repeatedStringForDryRun += "}"
	repeatedStringForMeasurementRetention := "[]MeasurementRetention{"
	for _, f := range this.MeasurementRetention {
		repeatedStringForMeasurementRetention += strings.Replace(strings.Replace(f.String(), "MeasurementRetention", "MeasurementRetention", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMeasurementRetention += "}"
	s := strings.Join([]string{`&AnalysisTemplateSpec{`,
		`Metrics:` + repeatedStringForMetrics + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`DryRun:` + repeatedStringForDryRun + `,`,
		`MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`,
		`}`,
	}, "")
	return s
}
func (this *Argument) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Argument{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + valueToStringGenerated(this.Value) + `,`,
		`ValueFrom:` + strings.Replace(this.ValueFrom.String(), "ValueFrom", "ValueFrom", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Authentication) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Authentication{`,
		`Sigv4:` + strings.Replace(strings.Replace(this.Sigv4.String(), "Sigv4Config", "Sigv4Config", 1), `&`, ``, 1) + `,`,
		`OAuth2:` + strings.Replace(strings.Replace(this.OAuth2.String(), "OAuth2Config", "OAuth2Config", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudWatchMetric) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMetricDataQueries := "[]CloudWatchMetricDataQuery{"
	for _, f := range this.MetricDataQueries {
		repeatedStringForMetricDataQueries += strings.Replace(strings.Replace(f.String(), "CloudWatchMetricDataQuery", "CloudWatchMetricDataQuery", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMetricDataQueries += "}"
	s := strings.Join([]string{`&CloudWatchMetric{`,
		`Interval:` + fmt.Sprintf("%v", this.Interval) + `,`,
		`MetricDataQueries:` + repeatedStringForMetricDataQueries + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudWatchMetricDataQuery) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CloudWatchMetricDataQuery{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Expression:` + valueToStringGenerated(this.Expression) + `,`,
		`Label:` + valueToStringGenerated(this.Label) + `,`,
		`MetricStat:` + strings.Replace(this.MetricStat.String(), "CloudWatchMetricStat", "CloudWatchMetricStat", 1) + `,`,
		`Period:` + strings.Replace(fmt.Sprintf("%v", this.Period), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`ReturnData:` + valueToStringGenerated(this.ReturnData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudWatchMetricStat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CloudWatchMetricStat{`,
		`Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "CloudWatchMetricStatMetric", "CloudWatchMetricStatMetric", 1), `&`, ``, 1) + `,`,
		`Period:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Period), "IntOrString", "intstr.IntOrString", 1), `&`, ``, 1) + `,`,
		`Stat:` + fmt.Sprintf("%v", this.Stat) + `,`,
		`Unit:` + fmt.Sprintf("%v", this.Unit) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudWatchMetricStatMetric) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForDimensions := "[]CloudWatchMetricStatMetricDimension{"
	for _, f := range this.Dimensions {
		repeatedStringForDimensions += strings.Replace(strings.Replace(f.String(), "CloudWatchMetricStatMetricDimension", "CloudWatchMetricStatMetricDimension", 1), `&`, ``, 1) + ","
	}
	repeatedStringForDimensions += "}"
	s := strings.Join([]string{`&CloudWatchMetricStatMetric{`,
		`Dimensions:` + repeatedStringForDimensions + `,`,
		`MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
		`Namespace:` + valueToStringGenerated(this.Namespace) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudWatchMetricStatMetricDimension) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CloudWatchMetricStatMetricDimension{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DatadogMetric) String() string {
	if this == nil {
		return "nil"
	}
	keysForQueries := make([]string, 0, len(this.Queries))
	for k := range this.Queries {
		keysForQueries = append(keysForQueries, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForQueries)
	mapStringForQueries := "map[string]string{"
	for _, k := range keysForQueries {
		mapStringForQueries += fmt.Sprintf("%v: %v,", k, this.Queries[k])
	}
	mapStringForQueries += "}"
	s := strings.Join([]string{`&DatadogMetric{`,
		`Interval:` + fmt.Sprintf("%v", this.Interval) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`Queries:` + mapStringForQueries + `,`,
		`Formula:` + fmt.Sprintf("%v", this.Formula) + `,`,
		`ApiVersion:` + fmt.Sprintf("%v", this.ApiVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DryRun) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DryRun{`,
		`MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FieldRef) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FieldRef{`,
		`FieldPath:` + fmt.Sprintf("%v", this.FieldPath) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GraphiteMetric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GraphiteMetric{`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`}`,
	}, "")
	return s
}
func (this *InfluxdbMetric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&InfluxdbMetric{`,
		`Profile:` + fmt.Sprintf("%v", this.Profile) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`}`,
	}, "")
	return s
}
func (this *JobMetric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&JobMetric{`,
		`Metadata:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Metadata), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Spec), "JobSpec", "v11.JobSpec", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KayentaMetric) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForScopes := "[]KayentaScope{"
	for _, f := range this.Scopes {
		repeatedStringForScopes += strings.Replace(strings.Replace(f.String(), "KayentaScope", "KayentaScope", 1), `&`, ``, 1) + ","
	}
	repeatedStringForScopes += "}"
	s := strings.Join([]string{`&KayentaMetric{`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`Application:` + fmt.Sprintf("%v", this.Application) + `,`,
		`CanaryConfigName:` + fmt.Sprintf("%v", this.CanaryConfigName) + `,`,
		`MetricsAccountName:` + fmt.Sprintf("%v", this.MetricsAccountName) + `,`,
		`ConfigurationAccountName:` + fmt.Sprintf("%v", this.ConfigurationAccountName) + `,`,
		`StorageAccountName:` + fmt.Sprintf("%v", this.StorageAccountName) + `,`,
		`Threshold:` + strings.Replace(strings.Replace(this.Threshold.String(), "KayentaThreshold", "KayentaThreshold", 1), `&`, ``, 1) + `,`,
		`Scopes:` + repeatedStringForScopes + `,`,
		`}`,
	}, "")
	return s
}
func (this *KayentaScope) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KayentaScope{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ControlScope:` + strings.Replace(strings.Replace(this.ControlScope.String(), "ScopeDetail", "ScopeDetail", 1), `&`, ``, 1) + `,`,
		`ExperimentScope:` + strings.Replace(strings.Replace(this.ExperimentScope.String(), "ScopeDetail", "ScopeDetail", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KayentaThreshold) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KayentaThreshold{`,
		`Pass:` + fmt.Sprintf("%v", this.Pass) + `,`,
		`Marginal:` + fmt.Sprintf("%v", this.Marginal) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Measurement) String() string {
	if this == nil {
		return "nil"
	}
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	s := strings.Join([]string{`&Measurement{`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`StartedAt:` + strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Time", "v1.Time", 1) + `,`,
		`FinishedAt:` + strings.Replace(fmt.Sprintf("%v", this.FinishedAt), "Time", "v1.Time", 1) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`Metadata:` + mapStringForMetadata + `,`,
		`ResumeAt:` + strings.Replace(fmt.Sprintf("%v", this.ResumeAt), "Time", "v1.Time", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MeasurementRetention) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MeasurementRetention{`,
		`MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
		`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Metric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Metric{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Interval:` + fmt.Sprintf("%v", this.Interval) + `,`,
		`InitialDelay:` + fmt.Sprintf("%v", this.InitialDelay) + `,`,
		`Count:` + strings.Replace(fmt.Sprintf("%v", this.Count), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`SuccessCondition:` + fmt.Sprintf("%v", this.SuccessCondition) + `,`,
		`FailureCondition:` + fmt.Sprintf("%v", this.FailureCondition) + `,`,
		`FailureLimit:` + strings.Replace(fmt.Sprintf("%v", this.FailureLimit), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`InconclusiveLimit:` + strings.Replace(fmt.Sprintf("%v", this.InconclusiveLimit), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`ConsecutiveErrorLimit:` + strings.Replace(fmt.Sprintf("%v", this.ConsecutiveErrorLimit), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`Provider:` + strings.Replace(strings.Replace(this.Provider.String(), "MetricProvider", "MetricProvider", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetricProvider) String() string {
	if this == nil {
		return "nil"
	}
	keysForPlugin := make([]string, 0, len(this.Plugin))
	for k := range this.Plugin {
		keysForPlugin = append(keysForPlugin, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForPlugin)
	mapStringForPlugin := "map[string]encoding_json.RawMessage{"
	for _, k := range keysForPlugin {
		mapStringForPlugin += fmt.Sprintf("%v: %v,", k, this.Plugin[k])
	}
	mapStringForPlugin += "}"
	s := strings.Join([]string{`&MetricProvider{`,
		`Prometheus:` + strings.Replace(this.Prometheus.String(), "PrometheusMetric", "PrometheusMetric", 1) + `,`,
		`Kayenta:` + strings.Replace(this.Kayenta.String(), "KayentaMetric", "KayentaMetric", 1) + `,`,
		`Web:` + strings.Replace(this.Web.String(), "WebMetric", "WebMetric", 1) + `,`,
		`Datadog:` + strings.Replace(this.Datadog.String(), "DatadogMetric", "DatadogMetric", 1) + `,`,
		`Wavefront:` + strings.Replace(this.Wavefront.String(), "WavefrontMetric", "WavefrontMetric", 1) + `,`,
		`NewRelic:` + strings.Replace(this.NewRelic.String(), "NewRelicMetric", "NewRelicMetric", 1) + `,`,
		`Job:` + strings.Replace(this.Job.String(), "JobMetric", "JobMetric", 1) + `,`,
		`CloudWatch:` + strings.Replace(this.CloudWatch.String(), "CloudWatchMetric", "CloudWatchMetric", 1) + `,`,
		`Graphite:` + strings.Replace(this.Graphite.String(), "GraphiteMetric", "GraphiteMetric", 1) + `,`,
		`Influxdb:` + strings.Replace(this.Influxdb.String(), "InfluxdbMetric", "InfluxdbMetric", 1) + `,`,
		`SkyWalking:` + strings.Replace(this.SkyWalking.String(), "SkyWalkingMetric", "SkyWalkingMetric", 1) + `,`,
		`Plugin:` + mapStringForPlugin + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetricResult) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMeasurements := "[]Measurement{"
	for _, f := range this.Measurements {
		repeatedStringForMeasurements += strings.Replace(strings.Replace(f.String(), "Measurement", "Measurement", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMeasurements += "}"
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	s := strings.Join([]string{`&MetricResult{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Measurements:` + repeatedStringForMeasurements + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`Successful:` + fmt.Sprintf("%v", this.Successful) + `,`,
		`Failed:` + fmt.Sprintf("%v", this.Failed) + `,`,
		`Inconclusive:` + fmt.Sprintf("%v", this.Inconclusive) + `,`,
		`Error:` + fmt.Sprintf("%v", this.Error) + `,`,
		`ConsecutiveError:` + fmt.Sprintf("%v", this.ConsecutiveError) + `,`,
		`DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
		`Metadata:` + mapStringForMetadata + `,`,
		`}`,
	}, "")
	return s
}
func (this *NewRelicMetric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NewRelicMetric{`,
		`Profile:` + fmt.Sprintf("%v", this.Profile) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OAuth2Config) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OAuth2Config{`,
		`TokenURL:` + fmt.Sprintf("%v", this.TokenURL) + `,`,
		`ClientID:` + fmt.Sprintf("%v", this.ClientID) + `,`,
		`ClientSecret:` + fmt.Sprintf("%v", this.ClientSecret) + `,`,
		`Scopes:` + fmt.Sprintf("%v", this.Scopes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PrometheusMetric) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForHeaders := "[]WebMetricHeader{"
	for _, f := range this.Headers {
		repeatedStringForHeaders += strings.Replace(strings.Replace(f.String(), "WebMetricHeader", "WebMetricHeader", 1), `&`, ``, 1) + ","
	}
	repeatedStringForHeaders += "}"
	s := strings.Join([]string{`&PrometheusMetric{`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`Authentication:` + strings.Replace(strings.Replace(this.Authentication.String(), "Authentication", "Authentication", 1), `&`, ``, 1) + `,`,
		`Timeout:` + valueToStringGenerated(this.Timeout) + `,`,
		`Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`,
		`Headers:` + repeatedStringForHeaders + `,`,
		`}`,
	}, "")
	return s
}
func (this *RunSummary) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RunSummary{`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`Successful:` + fmt.Sprintf("%v", this.Successful) + `,`,
		`Failed:` + fmt.Sprintf("%v", this.Failed) + `,`,
		`Inconclusive:` + fmt.Sprintf("%v", this.Inconclusive) + `,`,
		`Error:` + fmt.Sprintf("%v", this.Error) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScopeDetail) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScopeDetail{`,
		`Scope:` + fmt.Sprintf("%v", this.Scope) + `,`,
		`Region:` + fmt.Sprintf("%v", this.Region) + `,`,
		`Step:` + fmt.Sprintf("%v", this.Step) + `,`,
		`Start:` + fmt.Sprintf("%v", this.Start) + `,`,
		`End:` + fmt.Sprintf("%v", this.End) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SecretKeyRef) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SecretKeyRef{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Sigv4Config) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Sigv4Config{`,
		`Region:` + fmt.Sprintf("%v", this.Region) + `,`,
		`Profile:` + fmt.Sprintf("%v", this.Profile) + `,`,
		`RoleARN:` + fmt.Sprintf("%v", this.RoleARN) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SkyWalkingMetric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SkyWalkingMetric{`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`Interval:` + fmt.Sprintf("%v", this.Interval) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ValueFrom) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ValueFrom{`,
		`SecretKeyRef:` + strings.Replace(this.SecretKeyRef.String(), "SecretKeyRef", "SecretKeyRef", 1) + `,`,
		`FieldRef:` + strings.Replace(this.FieldRef.String(), "FieldRef", "FieldRef", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WavefrontMetric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WavefrontMetric{`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WebMetric) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForHeaders := "[]WebMetricHeader{"
	for _, f := range this.Headers {
		repeatedStringForHeaders += strings.Replace(strings.Replace(f.String(), "WebMetricHeader", "WebMetricHeader", 1), `&`, ``, 1) + ","
	}
	repeatedStringForHeaders += "}"
	s := strings.Join([]string{`&WebMetric{`,
		`Method:` + fmt.Sprintf("%v", this.Method) + `,`,
		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
		`Headers:` + repeatedStringForHeaders + `,`,
		`Body:` + fmt.Sprintf("%v", this.Body) + `,`,
		`TimeoutSeconds:` + fmt.Sprintf("%v", this.TimeoutSeconds) + `,`,
		`JSONPath:` + fmt.Sprintf("%v", this.JSONPath) + `,`,
		`Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`,
		`JSONBody:` + valueToStringGenerated(this.JSONBody) + `,`,
		`Authentication:` + strings.Replace(strings.Replace(this.Authentication.String(), "Authentication", "Authentication", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WebMetricHeader) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WebMetricHeader{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringGenerated(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *AnalysisRun) 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 ErrIntOverflowGenerated
			}
			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: AnalysisRun: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRun: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisRunList) 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 ErrIntOverflowGenerated
			}
			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: AnalysisRunList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, AnalysisRun{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisRunSpec) 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 ErrIntOverflowGenerated
			}
			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: AnalysisRunSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metrics = append(m.Metrics, Metric{})
			if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, Argument{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Terminate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Terminate = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DryRun = append(m.DryRun, DryRun{})
			if err := m.DryRun[len(m.DryRun)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeasurementRetention", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MeasurementRetention = append(m.MeasurementRetention, MeasurementRetention{})
			if err := m.MeasurementRetention[len(m.MeasurementRetention)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisRunStatus) 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 ErrIntOverflowGenerated
			}
			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: AnalysisRunStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricResults", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricResults = append(m.MetricResults, MetricResult{})
			if err := m.MetricResults[len(m.MetricResults)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StartedAt == nil {
				m.StartedAt = &v1.Time{}
			}
			if err := m.StartedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunSummary", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RunSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DryRunSummary", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DryRunSummary == nil {
				m.DryRunSummary = &RunSummary{}
			}
			if err := m.DryRunSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisTemplate) 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 ErrIntOverflowGenerated
			}
			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: AnalysisTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisTemplateList) 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 ErrIntOverflowGenerated
			}
			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: AnalysisTemplateList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisTemplateList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, AnalysisTemplate{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisTemplateSpec) 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 ErrIntOverflowGenerated
			}
			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: AnalysisTemplateSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metrics = append(m.Metrics, Metric{})
			if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, Argument{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DryRun = append(m.DryRun, DryRun{})
			if err := m.DryRun[len(m.DryRun)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeasurementRetention", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MeasurementRetention = append(m.MeasurementRetention, MeasurementRetention{})
			if err := m.MeasurementRetention[len(m.MeasurementRetention)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Argument) 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 ErrIntOverflowGenerated
			}
			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: Argument: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Argument: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Value = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueFrom", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueFrom == nil {
				m.ValueFrom = &ValueFrom{}
			}
			if err := m.ValueFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Authentication) 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 ErrIntOverflowGenerated
			}
			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: Authentication: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Authentication: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sigv4", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Sigv4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OAuth2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OAuth2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudWatchMetric) 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 ErrIntOverflowGenerated
			}
			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: CloudWatchMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudWatchMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interval = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricDataQueries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricDataQueries = append(m.MetricDataQueries, CloudWatchMetricDataQuery{})
			if err := m.MetricDataQueries[len(m.MetricDataQueries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudWatchMetricDataQuery) 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 ErrIntOverflowGenerated
			}
			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: CloudWatchMetricDataQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudWatchMetricDataQuery: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expression", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Expression = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Label = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricStat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricStat == nil {
				m.MetricStat = &CloudWatchMetricStat{}
			}
			if err := m.MetricStat.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Period == nil {
				m.Period = &intstr.IntOrString{}
			}
			if err := m.Period.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReturnData", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.ReturnData = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudWatchMetricStat) 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 ErrIntOverflowGenerated
			}
			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: CloudWatchMetricStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudWatchMetricStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Period.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stat", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Stat = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudWatchMetricStatMetric) 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 ErrIntOverflowGenerated
			}
			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: CloudWatchMetricStatMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudWatchMetricStatMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dimensions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dimensions = append(m.Dimensions, CloudWatchMetricStatMetricDimension{})
			if err := m.Dimensions[len(m.Dimensions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Namespace = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudWatchMetricStatMetricDimension) 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 ErrIntOverflowGenerated
			}
			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: CloudWatchMetricStatMetricDimension: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudWatchMetricStatMetricDimension: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DatadogMetric) 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 ErrIntOverflowGenerated
			}
			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: DatadogMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatadogMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interval = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Queries == nil {
				m.Queries = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Queries[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Formula", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Formula = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApiVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DryRun) 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 ErrIntOverflowGenerated
			}
			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: DryRun: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DryRun: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FieldRef) 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 ErrIntOverflowGenerated
			}
			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: FieldRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FieldRef: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FieldPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GraphiteMetric) 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 ErrIntOverflowGenerated
			}
			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: GraphiteMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GraphiteMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InfluxdbMetric) 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 ErrIntOverflowGenerated
			}
			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: InfluxdbMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InfluxdbMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Profile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobMetric) 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 ErrIntOverflowGenerated
			}
			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: JobMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KayentaMetric) 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 ErrIntOverflowGenerated
			}
			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: KayentaMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KayentaMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Application", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Application = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanaryConfigName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CanaryConfigName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricsAccountName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricsAccountName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigurationAccountName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigurationAccountName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageAccountName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StorageAccountName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Threshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scopes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Scopes = append(m.Scopes, KayentaScope{})
			if err := m.Scopes[len(m.Scopes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KayentaScope) 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 ErrIntOverflowGenerated
			}
			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: KayentaScope: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KayentaScope: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlScope", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ControlScope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExperimentScope", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExperimentScope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KayentaThreshold) 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 ErrIntOverflowGenerated
			}
			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: KayentaThreshold: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KayentaThreshold: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pass", wireType)
			}
			m.Pass = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pass |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Marginal", wireType)
			}
			m.Marginal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Marginal |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Measurement) 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 ErrIntOverflowGenerated
			}
			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: Measurement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Measurement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StartedAt == nil {
				m.StartedAt = &v1.Time{}
			}
			if err := m.StartedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinishedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FinishedAt == nil {
				m.FinishedAt = &v1.Time{}
			}
			if err := m.FinishedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metadata[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResumeAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResumeAt == nil {
				m.ResumeAt = &v1.Time{}
			}
			if err := m.ResumeAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeasurementRetention) 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 ErrIntOverflowGenerated
			}
			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: MeasurementRetention: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeasurementRetention: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Metric) 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 ErrIntOverflowGenerated
			}
			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: Metric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interval = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialDelay", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitialDelay = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Count == nil {
				m.Count = &intstr.IntOrString{}
			}
			if err := m.Count.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SuccessCondition", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SuccessCondition = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailureCondition", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FailureCondition = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailureLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FailureLimit == nil {
				m.FailureLimit = &intstr.IntOrString{}
			}
			if err := m.FailureLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InconclusiveLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InconclusiveLimit == nil {
				m.InconclusiveLimit = &intstr.IntOrString{}
			}
			if err := m.InconclusiveLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveErrorLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsecutiveErrorLimit == nil {
				m.ConsecutiveErrorLimit = &intstr.IntOrString{}
			}
			if err := m.ConsecutiveErrorLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Provider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetricProvider) 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 ErrIntOverflowGenerated
			}
			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: MetricProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetricProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prometheus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prometheus == nil {
				m.Prometheus = &PrometheusMetric{}
			}
			if err := m.Prometheus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kayenta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kayenta == nil {
				m.Kayenta = &KayentaMetric{}
			}
			if err := m.Kayenta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Web", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Web == nil {
				m.Web = &WebMetric{}
			}
			if err := m.Web.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Datadog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Datadog == nil {
				m.Datadog = &DatadogMetric{}
			}
			if err := m.Datadog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Wavefront", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Wavefront == nil {
				m.Wavefront = &WavefrontMetric{}
			}
			if err := m.Wavefront.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewRelic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NewRelic == nil {
				m.NewRelic = &NewRelicMetric{}
			}
			if err := m.NewRelic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Job", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Job == nil {
				m.Job = &JobMetric{}
			}
			if err := m.Job.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloudWatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CloudWatch == nil {
				m.CloudWatch = &CloudWatchMetric{}
			}
			if err := m.CloudWatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Graphite", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Graphite == nil {
				m.Graphite = &GraphiteMetric{}
			}
			if err := m.Graphite.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Influxdb", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Influxdb == nil {
				m.Influxdb = &InfluxdbMetric{}
			}
			if err := m.Influxdb.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkyWalking", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SkyWalking == nil {
				m.SkyWalking = &SkyWalkingMetric{}
			}
			if err := m.SkyWalking.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Plugin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Plugin == nil {
				m.Plugin = make(map[string]encoding_json.RawMessage)
			}
			var mapkey string
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthGenerated
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthGenerated
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Plugin[mapkey] = ((encoding_json.RawMessage)(mapvalue))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetricResult) 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 ErrIntOverflowGenerated
			}
			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: MetricResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetricResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Measurements", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Measurements = append(m.Measurements, Measurement{})
			if err := m.Measurements[len(m.Measurements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Successful", wireType)
			}
			m.Successful = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Successful |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
			}
			m.Failed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Failed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inconclusive", wireType)
			}
			m.Inconclusive = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Inconclusive |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			m.Error = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Error |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveError", wireType)
			}
			m.ConsecutiveError = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConsecutiveError |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DryRun = bool(v != 0)
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metadata[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NewRelicMetric) 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 ErrIntOverflowGenerated
			}
			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: NewRelicMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NewRelicMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Profile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OAuth2Config) 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 ErrIntOverflowGenerated
			}
			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: OAuth2Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OAuth2Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientSecret", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientSecret = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scopes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Scopes = append(m.Scopes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PrometheusMetric) 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 ErrIntOverflowGenerated
			}
			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: PrometheusMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PrometheusMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Authentication", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Authentication.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Timeout = &v
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Insecure = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Headers = append(m.Headers, WebMetricHeader{})
			if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RunSummary) 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 ErrIntOverflowGenerated
			}
			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: RunSummary: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RunSummary: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Successful", wireType)
			}
			m.Successful = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Successful |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
			}
			m.Failed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Failed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inconclusive", wireType)
			}
			m.Inconclusive = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Inconclusive |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			m.Error = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Error |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScopeDetail) 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 ErrIntOverflowGenerated
			}
			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: ScopeDetail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScopeDetail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Scope = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
			}
			m.Step = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Step |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Start = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.End = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SecretKeyRef) 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 ErrIntOverflowGenerated
			}
			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: SecretKeyRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SecretKeyRef: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sigv4Config) 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 ErrIntOverflowGenerated
			}
			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: Sigv4Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sigv4Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Profile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoleARN", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RoleARN = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SkyWalkingMetric) 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 ErrIntOverflowGenerated
			}
			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: SkyWalkingMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SkyWalkingMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interval = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValueFrom) 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 ErrIntOverflowGenerated
			}
			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: ValueFrom: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValueFrom: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretKeyRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SecretKeyRef == nil {
				m.SecretKeyRef = &SecretKeyRef{}
			}
			if err := m.SecretKeyRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FieldRef == nil {
				m.FieldRef = &FieldRef{}
			}
			if err := m.FieldRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WavefrontMetric) 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 ErrIntOverflowGenerated
			}
			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: WavefrontMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WavefrontMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WebMetric) 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 ErrIntOverflowGenerated
			}
			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: WebMetric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebMetric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Method = WebMetricMethod(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Headers = append(m.Headers, WebMetricHeader{})
			if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Body = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
			}
			m.TimeoutSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeoutSeconds |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JSONPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JSONPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Insecure = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JSONBody", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JSONBody = append(m.JSONBody[:0], dAtA[iNdEx:postIndex]...)
			if m.JSONBody == nil {
				m.JSONBody = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Authentication", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Authentication.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WebMetricHeader) 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 ErrIntOverflowGenerated
			}
			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: WebMetricHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebMetricHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenerated(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGenerated
			}
			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, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				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, ErrInvalidLengthGenerated
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenerated
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenerated
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
)
