/*
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/argoproj/argo-rollouts/pkg/apis/rollouts/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"
	k8s_io_api_core_v1 "k8s.io/api/core/v1"
	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 *ALBStatus) Reset()      { *m = ALBStatus{} }
func (*ALBStatus) ProtoMessage() {}
func (*ALBStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{0}
}
func (m *ALBStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ALBStatus) 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 *ALBStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ALBStatus.Merge(m, src)
}
func (m *ALBStatus) XXX_Size() int {
	return m.Size()
}
func (m *ALBStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ALBStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ALBStatus proto.InternalMessageInfo

func (m *ALBTrafficRouting) Reset()      { *m = ALBTrafficRouting{} }
func (*ALBTrafficRouting) ProtoMessage() {}
func (*ALBTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{1}
}
func (m *ALBTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ALBTrafficRouting) 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 *ALBTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ALBTrafficRouting.Merge(m, src)
}
func (m *ALBTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *ALBTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_ALBTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_ALBTrafficRouting proto.InternalMessageInfo

func (m *AmbassadorTrafficRouting) Reset()      { *m = AmbassadorTrafficRouting{} }
func (*AmbassadorTrafficRouting) ProtoMessage() {}
func (*AmbassadorTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{2}
}
func (m *AmbassadorTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AmbassadorTrafficRouting) 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 *AmbassadorTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AmbassadorTrafficRouting.Merge(m, src)
}
func (m *AmbassadorTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *AmbassadorTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_AmbassadorTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_AmbassadorTrafficRouting proto.InternalMessageInfo

func (m *AnalysisRun) Reset()      { *m = AnalysisRun{} }
func (*AnalysisRun) ProtoMessage() {}
func (*AnalysisRun) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{3}
}
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 *AnalysisRunArgument) Reset()      { *m = AnalysisRunArgument{} }
func (*AnalysisRunArgument) ProtoMessage() {}
func (*AnalysisRunArgument) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{4}
}
func (m *AnalysisRunArgument) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRunArgument) 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 *AnalysisRunArgument) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRunArgument.Merge(m, src)
}
func (m *AnalysisRunArgument) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRunArgument) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRunArgument.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRunArgument proto.InternalMessageInfo

func (m *AnalysisRunList) Reset()      { *m = AnalysisRunList{} }
func (*AnalysisRunList) ProtoMessage() {}
func (*AnalysisRunList) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{5}
}
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 *AnalysisRunMetadata) Reset()      { *m = AnalysisRunMetadata{} }
func (*AnalysisRunMetadata) ProtoMessage() {}
func (*AnalysisRunMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{6}
}
func (m *AnalysisRunMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRunMetadata) 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 *AnalysisRunMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRunMetadata.Merge(m, src)
}
func (m *AnalysisRunMetadata) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRunMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRunMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRunMetadata proto.InternalMessageInfo

func (m *AnalysisRunSpec) Reset()      { *m = AnalysisRunSpec{} }
func (*AnalysisRunSpec) ProtoMessage() {}
func (*AnalysisRunSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{7}
}
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_e0e705f843545fab, []int{8}
}
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 *AnalysisRunStrategy) Reset()      { *m = AnalysisRunStrategy{} }
func (*AnalysisRunStrategy) ProtoMessage() {}
func (*AnalysisRunStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{9}
}
func (m *AnalysisRunStrategy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisRunStrategy) 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 *AnalysisRunStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisRunStrategy.Merge(m, src)
}
func (m *AnalysisRunStrategy) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisRunStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisRunStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisRunStrategy proto.InternalMessageInfo

func (m *AnalysisTemplate) Reset()      { *m = AnalysisTemplate{} }
func (*AnalysisTemplate) ProtoMessage() {}
func (*AnalysisTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{10}
}
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_e0e705f843545fab, []int{11}
}
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 *AnalysisTemplateRef) Reset()      { *m = AnalysisTemplateRef{} }
func (*AnalysisTemplateRef) ProtoMessage() {}
func (*AnalysisTemplateRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{12}
}
func (m *AnalysisTemplateRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalysisTemplateRef) 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 *AnalysisTemplateRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisTemplateRef.Merge(m, src)
}
func (m *AnalysisTemplateRef) XXX_Size() int {
	return m.Size()
}
func (m *AnalysisTemplateRef) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisTemplateRef.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisTemplateRef proto.InternalMessageInfo

func (m *AnalysisTemplateSpec) Reset()      { *m = AnalysisTemplateSpec{} }
func (*AnalysisTemplateSpec) ProtoMessage() {}
func (*AnalysisTemplateSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{13}
}
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 *AntiAffinity) Reset()      { *m = AntiAffinity{} }
func (*AntiAffinity) ProtoMessage() {}
func (*AntiAffinity) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{14}
}
func (m *AntiAffinity) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AntiAffinity) 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 *AntiAffinity) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AntiAffinity.Merge(m, src)
}
func (m *AntiAffinity) XXX_Size() int {
	return m.Size()
}
func (m *AntiAffinity) XXX_DiscardUnknown() {
	xxx_messageInfo_AntiAffinity.DiscardUnknown(m)
}

var xxx_messageInfo_AntiAffinity proto.InternalMessageInfo

func (m *ApisixRoute) Reset()      { *m = ApisixRoute{} }
func (*ApisixRoute) ProtoMessage() {}
func (*ApisixRoute) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{15}
}
func (m *ApisixRoute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApisixRoute) 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 *ApisixRoute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApisixRoute.Merge(m, src)
}
func (m *ApisixRoute) XXX_Size() int {
	return m.Size()
}
func (m *ApisixRoute) XXX_DiscardUnknown() {
	xxx_messageInfo_ApisixRoute.DiscardUnknown(m)
}

var xxx_messageInfo_ApisixRoute proto.InternalMessageInfo

func (m *ApisixTrafficRouting) Reset()      { *m = ApisixTrafficRouting{} }
func (*ApisixTrafficRouting) ProtoMessage() {}
func (*ApisixTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{16}
}
func (m *ApisixTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApisixTrafficRouting) 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 *ApisixTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApisixTrafficRouting.Merge(m, src)
}
func (m *ApisixTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *ApisixTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_ApisixTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_ApisixTrafficRouting proto.InternalMessageInfo

func (m *AppMeshTrafficRouting) Reset()      { *m = AppMeshTrafficRouting{} }
func (*AppMeshTrafficRouting) ProtoMessage() {}
func (*AppMeshTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{17}
}
func (m *AppMeshTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppMeshTrafficRouting) 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 *AppMeshTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppMeshTrafficRouting.Merge(m, src)
}
func (m *AppMeshTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *AppMeshTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_AppMeshTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_AppMeshTrafficRouting proto.InternalMessageInfo

func (m *AppMeshVirtualNodeGroup) Reset()      { *m = AppMeshVirtualNodeGroup{} }
func (*AppMeshVirtualNodeGroup) ProtoMessage() {}
func (*AppMeshVirtualNodeGroup) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{18}
}
func (m *AppMeshVirtualNodeGroup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppMeshVirtualNodeGroup) 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 *AppMeshVirtualNodeGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppMeshVirtualNodeGroup.Merge(m, src)
}
func (m *AppMeshVirtualNodeGroup) XXX_Size() int {
	return m.Size()
}
func (m *AppMeshVirtualNodeGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_AppMeshVirtualNodeGroup.DiscardUnknown(m)
}

var xxx_messageInfo_AppMeshVirtualNodeGroup proto.InternalMessageInfo

func (m *AppMeshVirtualNodeReference) Reset()      { *m = AppMeshVirtualNodeReference{} }
func (*AppMeshVirtualNodeReference) ProtoMessage() {}
func (*AppMeshVirtualNodeReference) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{19}
}
func (m *AppMeshVirtualNodeReference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppMeshVirtualNodeReference) 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 *AppMeshVirtualNodeReference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppMeshVirtualNodeReference.Merge(m, src)
}
func (m *AppMeshVirtualNodeReference) XXX_Size() int {
	return m.Size()
}
func (m *AppMeshVirtualNodeReference) XXX_DiscardUnknown() {
	xxx_messageInfo_AppMeshVirtualNodeReference.DiscardUnknown(m)
}

var xxx_messageInfo_AppMeshVirtualNodeReference proto.InternalMessageInfo

func (m *AppMeshVirtualService) Reset()      { *m = AppMeshVirtualService{} }
func (*AppMeshVirtualService) ProtoMessage() {}
func (*AppMeshVirtualService) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{20}
}
func (m *AppMeshVirtualService) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppMeshVirtualService) 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 *AppMeshVirtualService) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppMeshVirtualService.Merge(m, src)
}
func (m *AppMeshVirtualService) XXX_Size() int {
	return m.Size()
}
func (m *AppMeshVirtualService) XXX_DiscardUnknown() {
	xxx_messageInfo_AppMeshVirtualService.DiscardUnknown(m)
}

var xxx_messageInfo_AppMeshVirtualService proto.InternalMessageInfo

func (m *Argument) Reset()      { *m = Argument{} }
func (*Argument) ProtoMessage() {}
func (*Argument) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{21}
}
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 *ArgumentValueFrom) Reset()      { *m = ArgumentValueFrom{} }
func (*ArgumentValueFrom) ProtoMessage() {}
func (*ArgumentValueFrom) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{22}
}
func (m *ArgumentValueFrom) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ArgumentValueFrom) 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 *ArgumentValueFrom) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ArgumentValueFrom.Merge(m, src)
}
func (m *ArgumentValueFrom) XXX_Size() int {
	return m.Size()
}
func (m *ArgumentValueFrom) XXX_DiscardUnknown() {
	xxx_messageInfo_ArgumentValueFrom.DiscardUnknown(m)
}

var xxx_messageInfo_ArgumentValueFrom proto.InternalMessageInfo

func (m *Authentication) Reset()      { *m = Authentication{} }
func (*Authentication) ProtoMessage() {}
func (*Authentication) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{23}
}
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 *AwsResourceRef) Reset()      { *m = AwsResourceRef{} }
func (*AwsResourceRef) ProtoMessage() {}
func (*AwsResourceRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{24}
}
func (m *AwsResourceRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AwsResourceRef) 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 *AwsResourceRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AwsResourceRef.Merge(m, src)
}
func (m *AwsResourceRef) XXX_Size() int {
	return m.Size()
}
func (m *AwsResourceRef) XXX_DiscardUnknown() {
	xxx_messageInfo_AwsResourceRef.DiscardUnknown(m)
}

var xxx_messageInfo_AwsResourceRef proto.InternalMessageInfo

func (m *BlueGreenStatus) Reset()      { *m = BlueGreenStatus{} }
func (*BlueGreenStatus) ProtoMessage() {}
func (*BlueGreenStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{25}
}
func (m *BlueGreenStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlueGreenStatus) 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 *BlueGreenStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlueGreenStatus.Merge(m, src)
}
func (m *BlueGreenStatus) XXX_Size() int {
	return m.Size()
}
func (m *BlueGreenStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_BlueGreenStatus.DiscardUnknown(m)
}

var xxx_messageInfo_BlueGreenStatus proto.InternalMessageInfo

func (m *BlueGreenStrategy) Reset()      { *m = BlueGreenStrategy{} }
func (*BlueGreenStrategy) ProtoMessage() {}
func (*BlueGreenStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{26}
}
func (m *BlueGreenStrategy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlueGreenStrategy) 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 *BlueGreenStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlueGreenStrategy.Merge(m, src)
}
func (m *BlueGreenStrategy) XXX_Size() int {
	return m.Size()
}
func (m *BlueGreenStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_BlueGreenStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_BlueGreenStrategy proto.InternalMessageInfo

func (m *CanaryStatus) Reset()      { *m = CanaryStatus{} }
func (*CanaryStatus) ProtoMessage() {}
func (*CanaryStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{27}
}
func (m *CanaryStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CanaryStatus) 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 *CanaryStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CanaryStatus.Merge(m, src)
}
func (m *CanaryStatus) XXX_Size() int {
	return m.Size()
}
func (m *CanaryStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_CanaryStatus.DiscardUnknown(m)
}

var xxx_messageInfo_CanaryStatus proto.InternalMessageInfo

func (m *CanaryStep) Reset()      { *m = CanaryStep{} }
func (*CanaryStep) ProtoMessage() {}
func (*CanaryStep) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{28}
}
func (m *CanaryStep) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CanaryStep) 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 *CanaryStep) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CanaryStep.Merge(m, src)
}
func (m *CanaryStep) XXX_Size() int {
	return m.Size()
}
func (m *CanaryStep) XXX_DiscardUnknown() {
	xxx_messageInfo_CanaryStep.DiscardUnknown(m)
}

var xxx_messageInfo_CanaryStep proto.InternalMessageInfo

func (m *CanaryStrategy) Reset()      { *m = CanaryStrategy{} }
func (*CanaryStrategy) ProtoMessage() {}
func (*CanaryStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{29}
}
func (m *CanaryStrategy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CanaryStrategy) 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 *CanaryStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CanaryStrategy.Merge(m, src)
}
func (m *CanaryStrategy) XXX_Size() int {
	return m.Size()
}
func (m *CanaryStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_CanaryStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_CanaryStrategy proto.InternalMessageInfo

func (m *CloudWatchMetric) Reset()      { *m = CloudWatchMetric{} }
func (*CloudWatchMetric) ProtoMessage() {}
func (*CloudWatchMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{30}
}
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_e0e705f843545fab, []int{31}
}
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_e0e705f843545fab, []int{32}
}
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_e0e705f843545fab, []int{33}
}
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_e0e705f843545fab, []int{34}
}
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 *ClusterAnalysisTemplate) Reset()      { *m = ClusterAnalysisTemplate{} }
func (*ClusterAnalysisTemplate) ProtoMessage() {}
func (*ClusterAnalysisTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{35}
}
func (m *ClusterAnalysisTemplate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterAnalysisTemplate) 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 *ClusterAnalysisTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterAnalysisTemplate.Merge(m, src)
}
func (m *ClusterAnalysisTemplate) XXX_Size() int {
	return m.Size()
}
func (m *ClusterAnalysisTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterAnalysisTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterAnalysisTemplate proto.InternalMessageInfo

func (m *ClusterAnalysisTemplateList) Reset()      { *m = ClusterAnalysisTemplateList{} }
func (*ClusterAnalysisTemplateList) ProtoMessage() {}
func (*ClusterAnalysisTemplateList) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{36}
}
func (m *ClusterAnalysisTemplateList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterAnalysisTemplateList) 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 *ClusterAnalysisTemplateList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterAnalysisTemplateList.Merge(m, src)
}
func (m *ClusterAnalysisTemplateList) XXX_Size() int {
	return m.Size()
}
func (m *ClusterAnalysisTemplateList) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterAnalysisTemplateList.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterAnalysisTemplateList proto.InternalMessageInfo

func (m *DatadogMetric) Reset()      { *m = DatadogMetric{} }
func (*DatadogMetric) ProtoMessage() {}
func (*DatadogMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{37}
}
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_e0e705f843545fab, []int{38}
}
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 *Experiment) Reset()      { *m = Experiment{} }
func (*Experiment) ProtoMessage() {}
func (*Experiment) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{39}
}
func (m *Experiment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Experiment) 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 *Experiment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Experiment.Merge(m, src)
}
func (m *Experiment) XXX_Size() int {
	return m.Size()
}
func (m *Experiment) XXX_DiscardUnknown() {
	xxx_messageInfo_Experiment.DiscardUnknown(m)
}

var xxx_messageInfo_Experiment proto.InternalMessageInfo

func (m *ExperimentAnalysisRunStatus) Reset()      { *m = ExperimentAnalysisRunStatus{} }
func (*ExperimentAnalysisRunStatus) ProtoMessage() {}
func (*ExperimentAnalysisRunStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{40}
}
func (m *ExperimentAnalysisRunStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExperimentAnalysisRunStatus) 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 *ExperimentAnalysisRunStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExperimentAnalysisRunStatus.Merge(m, src)
}
func (m *ExperimentAnalysisRunStatus) XXX_Size() int {
	return m.Size()
}
func (m *ExperimentAnalysisRunStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ExperimentAnalysisRunStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ExperimentAnalysisRunStatus proto.InternalMessageInfo

func (m *ExperimentAnalysisTemplateRef) Reset()      { *m = ExperimentAnalysisTemplateRef{} }
func (*ExperimentAnalysisTemplateRef) ProtoMessage() {}
func (*ExperimentAnalysisTemplateRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{41}
}
func (m *ExperimentAnalysisTemplateRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExperimentAnalysisTemplateRef) 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 *ExperimentAnalysisTemplateRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExperimentAnalysisTemplateRef.Merge(m, src)
}
func (m *ExperimentAnalysisTemplateRef) XXX_Size() int {
	return m.Size()
}
func (m *ExperimentAnalysisTemplateRef) XXX_DiscardUnknown() {
	xxx_messageInfo_ExperimentAnalysisTemplateRef.DiscardUnknown(m)
}

var xxx_messageInfo_ExperimentAnalysisTemplateRef proto.InternalMessageInfo

func (m *ExperimentCondition) Reset()      { *m = ExperimentCondition{} }
func (*ExperimentCondition) ProtoMessage() {}
func (*ExperimentCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{42}
}
func (m *ExperimentCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExperimentCondition) 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 *ExperimentCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExperimentCondition.Merge(m, src)
}
func (m *ExperimentCondition) XXX_Size() int {
	return m.Size()
}
func (m *ExperimentCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_ExperimentCondition.DiscardUnknown(m)
}

var xxx_messageInfo_ExperimentCondition proto.InternalMessageInfo

func (m *ExperimentList) Reset()      { *m = ExperimentList{} }
func (*ExperimentList) ProtoMessage() {}
func (*ExperimentList) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{43}
}
func (m *ExperimentList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExperimentList) 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 *ExperimentList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExperimentList.Merge(m, src)
}
func (m *ExperimentList) XXX_Size() int {
	return m.Size()
}
func (m *ExperimentList) XXX_DiscardUnknown() {
	xxx_messageInfo_ExperimentList.DiscardUnknown(m)
}

var xxx_messageInfo_ExperimentList proto.InternalMessageInfo

func (m *ExperimentSpec) Reset()      { *m = ExperimentSpec{} }
func (*ExperimentSpec) ProtoMessage() {}
func (*ExperimentSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{44}
}
func (m *ExperimentSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExperimentSpec) 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 *ExperimentSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExperimentSpec.Merge(m, src)
}
func (m *ExperimentSpec) XXX_Size() int {
	return m.Size()
}
func (m *ExperimentSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ExperimentSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ExperimentSpec proto.InternalMessageInfo

func (m *ExperimentStatus) Reset()      { *m = ExperimentStatus{} }
func (*ExperimentStatus) ProtoMessage() {}
func (*ExperimentStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{45}
}
func (m *ExperimentStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExperimentStatus) 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 *ExperimentStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExperimentStatus.Merge(m, src)
}
func (m *ExperimentStatus) XXX_Size() int {
	return m.Size()
}
func (m *ExperimentStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ExperimentStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ExperimentStatus proto.InternalMessageInfo

func (m *FieldRef) Reset()      { *m = FieldRef{} }
func (*FieldRef) ProtoMessage() {}
func (*FieldRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{46}
}
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_e0e705f843545fab, []int{47}
}
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 *HeaderRoutingMatch) Reset()      { *m = HeaderRoutingMatch{} }
func (*HeaderRoutingMatch) ProtoMessage() {}
func (*HeaderRoutingMatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{48}
}
func (m *HeaderRoutingMatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeaderRoutingMatch) 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 *HeaderRoutingMatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderRoutingMatch.Merge(m, src)
}
func (m *HeaderRoutingMatch) XXX_Size() int {
	return m.Size()
}
func (m *HeaderRoutingMatch) XXX_DiscardUnknown() {
	xxx_messageInfo_HeaderRoutingMatch.DiscardUnknown(m)
}

var xxx_messageInfo_HeaderRoutingMatch proto.InternalMessageInfo

func (m *InfluxdbMetric) Reset()      { *m = InfluxdbMetric{} }
func (*InfluxdbMetric) ProtoMessage() {}
func (*InfluxdbMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{49}
}
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 *IstioDestinationRule) Reset()      { *m = IstioDestinationRule{} }
func (*IstioDestinationRule) ProtoMessage() {}
func (*IstioDestinationRule) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{50}
}
func (m *IstioDestinationRule) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IstioDestinationRule) 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 *IstioDestinationRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IstioDestinationRule.Merge(m, src)
}
func (m *IstioDestinationRule) XXX_Size() int {
	return m.Size()
}
func (m *IstioDestinationRule) XXX_DiscardUnknown() {
	xxx_messageInfo_IstioDestinationRule.DiscardUnknown(m)
}

var xxx_messageInfo_IstioDestinationRule proto.InternalMessageInfo

func (m *IstioTrafficRouting) Reset()      { *m = IstioTrafficRouting{} }
func (*IstioTrafficRouting) ProtoMessage() {}
func (*IstioTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{51}
}
func (m *IstioTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IstioTrafficRouting) 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 *IstioTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IstioTrafficRouting.Merge(m, src)
}
func (m *IstioTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *IstioTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_IstioTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_IstioTrafficRouting proto.InternalMessageInfo

func (m *IstioVirtualService) Reset()      { *m = IstioVirtualService{} }
func (*IstioVirtualService) ProtoMessage() {}
func (*IstioVirtualService) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{52}
}
func (m *IstioVirtualService) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IstioVirtualService) 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 *IstioVirtualService) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IstioVirtualService.Merge(m, src)
}
func (m *IstioVirtualService) XXX_Size() int {
	return m.Size()
}
func (m *IstioVirtualService) XXX_DiscardUnknown() {
	xxx_messageInfo_IstioVirtualService.DiscardUnknown(m)
}

var xxx_messageInfo_IstioVirtualService proto.InternalMessageInfo

func (m *JobMetric) Reset()      { *m = JobMetric{} }
func (*JobMetric) ProtoMessage() {}
func (*JobMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{53}
}
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_e0e705f843545fab, []int{54}
}
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_e0e705f843545fab, []int{55}
}
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_e0e705f843545fab, []int{56}
}
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 *MangedRoutes) Reset()      { *m = MangedRoutes{} }
func (*MangedRoutes) ProtoMessage() {}
func (*MangedRoutes) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{57}
}
func (m *MangedRoutes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MangedRoutes) 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 *MangedRoutes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MangedRoutes.Merge(m, src)
}
func (m *MangedRoutes) XXX_Size() int {
	return m.Size()
}
func (m *MangedRoutes) XXX_DiscardUnknown() {
	xxx_messageInfo_MangedRoutes.DiscardUnknown(m)
}

var xxx_messageInfo_MangedRoutes proto.InternalMessageInfo

func (m *Measurement) Reset()      { *m = Measurement{} }
func (*Measurement) ProtoMessage() {}
func (*Measurement) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{58}
}
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_e0e705f843545fab, []int{59}
}
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_e0e705f843545fab, []int{60}
}
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_e0e705f843545fab, []int{61}
}
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_e0e705f843545fab, []int{62}
}
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_e0e705f843545fab, []int{63}
}
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 *NginxTrafficRouting) Reset()      { *m = NginxTrafficRouting{} }
func (*NginxTrafficRouting) ProtoMessage() {}
func (*NginxTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{64}
}
func (m *NginxTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NginxTrafficRouting) 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 *NginxTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NginxTrafficRouting.Merge(m, src)
}
func (m *NginxTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *NginxTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_NginxTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_NginxTrafficRouting proto.InternalMessageInfo

func (m *OAuth2Config) Reset()      { *m = OAuth2Config{} }
func (*OAuth2Config) ProtoMessage() {}
func (*OAuth2Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{65}
}
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 *ObjectRef) Reset()      { *m = ObjectRef{} }
func (*ObjectRef) ProtoMessage() {}
func (*ObjectRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{66}
}
func (m *ObjectRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ObjectRef) 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 *ObjectRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ObjectRef.Merge(m, src)
}
func (m *ObjectRef) XXX_Size() int {
	return m.Size()
}
func (m *ObjectRef) XXX_DiscardUnknown() {
	xxx_messageInfo_ObjectRef.DiscardUnknown(m)
}

var xxx_messageInfo_ObjectRef proto.InternalMessageInfo

func (m *PauseCondition) Reset()      { *m = PauseCondition{} }
func (*PauseCondition) ProtoMessage() {}
func (*PauseCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{67}
}
func (m *PauseCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PauseCondition) 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 *PauseCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PauseCondition.Merge(m, src)
}
func (m *PauseCondition) XXX_Size() int {
	return m.Size()
}
func (m *PauseCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_PauseCondition.DiscardUnknown(m)
}

var xxx_messageInfo_PauseCondition proto.InternalMessageInfo

func (m *PingPongSpec) Reset()      { *m = PingPongSpec{} }
func (*PingPongSpec) ProtoMessage() {}
func (*PingPongSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{68}
}
func (m *PingPongSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PingPongSpec) 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 *PingPongSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingPongSpec.Merge(m, src)
}
func (m *PingPongSpec) XXX_Size() int {
	return m.Size()
}
func (m *PingPongSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_PingPongSpec.DiscardUnknown(m)
}

var xxx_messageInfo_PingPongSpec proto.InternalMessageInfo

func (m *PluginStep) Reset()      { *m = PluginStep{} }
func (*PluginStep) ProtoMessage() {}
func (*PluginStep) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{69}
}
func (m *PluginStep) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PluginStep) 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 *PluginStep) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PluginStep.Merge(m, src)
}
func (m *PluginStep) XXX_Size() int {
	return m.Size()
}
func (m *PluginStep) XXX_DiscardUnknown() {
	xxx_messageInfo_PluginStep.DiscardUnknown(m)
}

var xxx_messageInfo_PluginStep proto.InternalMessageInfo

func (m *PodTemplateMetadata) Reset()      { *m = PodTemplateMetadata{} }
func (*PodTemplateMetadata) ProtoMessage() {}
func (*PodTemplateMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{70}
}
func (m *PodTemplateMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodTemplateMetadata) 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 *PodTemplateMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodTemplateMetadata.Merge(m, src)
}
func (m *PodTemplateMetadata) XXX_Size() int {
	return m.Size()
}
func (m *PodTemplateMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_PodTemplateMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_PodTemplateMetadata proto.InternalMessageInfo

func (m *PreferredDuringSchedulingIgnoredDuringExecution) Reset() {
	*m = PreferredDuringSchedulingIgnoredDuringExecution{}
}
func (*PreferredDuringSchedulingIgnoredDuringExecution) ProtoMessage() {}
func (*PreferredDuringSchedulingIgnoredDuringExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{71}
}
func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PreferredDuringSchedulingIgnoredDuringExecution) 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 *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution.Merge(m, src)
}
func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Size() int {
	return m.Size()
}
func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution.DiscardUnknown(m)
}

var xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution proto.InternalMessageInfo

func (m *PrometheusMetric) Reset()      { *m = PrometheusMetric{} }
func (*PrometheusMetric) ProtoMessage() {}
func (*PrometheusMetric) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{72}
}
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 *PrometheusRangeQueryArgs) Reset()      { *m = PrometheusRangeQueryArgs{} }
func (*PrometheusRangeQueryArgs) ProtoMessage() {}
func (*PrometheusRangeQueryArgs) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{73}
}
func (m *PrometheusRangeQueryArgs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PrometheusRangeQueryArgs) 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 *PrometheusRangeQueryArgs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrometheusRangeQueryArgs.Merge(m, src)
}
func (m *PrometheusRangeQueryArgs) XXX_Size() int {
	return m.Size()
}
func (m *PrometheusRangeQueryArgs) XXX_DiscardUnknown() {
	xxx_messageInfo_PrometheusRangeQueryArgs.DiscardUnknown(m)
}

var xxx_messageInfo_PrometheusRangeQueryArgs proto.InternalMessageInfo

func (m *ReplicaProgressThreshold) Reset()      { *m = ReplicaProgressThreshold{} }
func (*ReplicaProgressThreshold) ProtoMessage() {}
func (*ReplicaProgressThreshold) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{74}
}
func (m *ReplicaProgressThreshold) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaProgressThreshold) 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 *ReplicaProgressThreshold) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaProgressThreshold.Merge(m, src)
}
func (m *ReplicaProgressThreshold) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaProgressThreshold) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaProgressThreshold.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaProgressThreshold proto.InternalMessageInfo

func (m *RequiredDuringSchedulingIgnoredDuringExecution) Reset() {
	*m = RequiredDuringSchedulingIgnoredDuringExecution{}
}
func (*RequiredDuringSchedulingIgnoredDuringExecution) ProtoMessage() {}
func (*RequiredDuringSchedulingIgnoredDuringExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{75}
}
func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequiredDuringSchedulingIgnoredDuringExecution) 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 *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution.Merge(m, src)
}
func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Size() int {
	return m.Size()
}
func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution.DiscardUnknown(m)
}

var xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution proto.InternalMessageInfo

func (m *RollbackWindowSpec) Reset()      { *m = RollbackWindowSpec{} }
func (*RollbackWindowSpec) ProtoMessage() {}
func (*RollbackWindowSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{76}
}
func (m *RollbackWindowSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RollbackWindowSpec) 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 *RollbackWindowSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RollbackWindowSpec.Merge(m, src)
}
func (m *RollbackWindowSpec) XXX_Size() int {
	return m.Size()
}
func (m *RollbackWindowSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_RollbackWindowSpec.DiscardUnknown(m)
}

var xxx_messageInfo_RollbackWindowSpec proto.InternalMessageInfo

func (m *Rollout) Reset()      { *m = Rollout{} }
func (*Rollout) ProtoMessage() {}
func (*Rollout) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{77}
}
func (m *Rollout) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Rollout) 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 *Rollout) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Rollout.Merge(m, src)
}
func (m *Rollout) XXX_Size() int {
	return m.Size()
}
func (m *Rollout) XXX_DiscardUnknown() {
	xxx_messageInfo_Rollout.DiscardUnknown(m)
}

var xxx_messageInfo_Rollout proto.InternalMessageInfo

func (m *RolloutAnalysis) Reset()      { *m = RolloutAnalysis{} }
func (*RolloutAnalysis) ProtoMessage() {}
func (*RolloutAnalysis) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{78}
}
func (m *RolloutAnalysis) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutAnalysis) 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 *RolloutAnalysis) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutAnalysis.Merge(m, src)
}
func (m *RolloutAnalysis) XXX_Size() int {
	return m.Size()
}
func (m *RolloutAnalysis) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutAnalysis.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutAnalysis proto.InternalMessageInfo

func (m *RolloutAnalysisBackground) Reset()      { *m = RolloutAnalysisBackground{} }
func (*RolloutAnalysisBackground) ProtoMessage() {}
func (*RolloutAnalysisBackground) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{79}
}
func (m *RolloutAnalysisBackground) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutAnalysisBackground) 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 *RolloutAnalysisBackground) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutAnalysisBackground.Merge(m, src)
}
func (m *RolloutAnalysisBackground) XXX_Size() int {
	return m.Size()
}
func (m *RolloutAnalysisBackground) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutAnalysisBackground.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutAnalysisBackground proto.InternalMessageInfo

func (m *RolloutAnalysisRunStatus) Reset()      { *m = RolloutAnalysisRunStatus{} }
func (*RolloutAnalysisRunStatus) ProtoMessage() {}
func (*RolloutAnalysisRunStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{80}
}
func (m *RolloutAnalysisRunStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutAnalysisRunStatus) 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 *RolloutAnalysisRunStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutAnalysisRunStatus.Merge(m, src)
}
func (m *RolloutAnalysisRunStatus) XXX_Size() int {
	return m.Size()
}
func (m *RolloutAnalysisRunStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutAnalysisRunStatus.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutAnalysisRunStatus proto.InternalMessageInfo

func (m *RolloutCondition) Reset()      { *m = RolloutCondition{} }
func (*RolloutCondition) ProtoMessage() {}
func (*RolloutCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{81}
}
func (m *RolloutCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutCondition) 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 *RolloutCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutCondition.Merge(m, src)
}
func (m *RolloutCondition) XXX_Size() int {
	return m.Size()
}
func (m *RolloutCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutCondition.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutCondition proto.InternalMessageInfo

func (m *RolloutExperimentStep) Reset()      { *m = RolloutExperimentStep{} }
func (*RolloutExperimentStep) ProtoMessage() {}
func (*RolloutExperimentStep) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{82}
}
func (m *RolloutExperimentStep) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutExperimentStep) 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 *RolloutExperimentStep) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutExperimentStep.Merge(m, src)
}
func (m *RolloutExperimentStep) XXX_Size() int {
	return m.Size()
}
func (m *RolloutExperimentStep) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutExperimentStep.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutExperimentStep proto.InternalMessageInfo

func (m *RolloutExperimentStepAnalysisTemplateRef) Reset() {
	*m = RolloutExperimentStepAnalysisTemplateRef{}
}
func (*RolloutExperimentStepAnalysisTemplateRef) ProtoMessage() {}
func (*RolloutExperimentStepAnalysisTemplateRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{83}
}
func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutExperimentStepAnalysisTemplateRef) 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 *RolloutExperimentStepAnalysisTemplateRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef.Merge(m, src)
}
func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Size() int {
	return m.Size()
}
func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef proto.InternalMessageInfo

func (m *RolloutExperimentTemplate) Reset()      { *m = RolloutExperimentTemplate{} }
func (*RolloutExperimentTemplate) ProtoMessage() {}
func (*RolloutExperimentTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{84}
}
func (m *RolloutExperimentTemplate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutExperimentTemplate) 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 *RolloutExperimentTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutExperimentTemplate.Merge(m, src)
}
func (m *RolloutExperimentTemplate) XXX_Size() int {
	return m.Size()
}
func (m *RolloutExperimentTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutExperimentTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutExperimentTemplate proto.InternalMessageInfo

func (m *RolloutList) Reset()      { *m = RolloutList{} }
func (*RolloutList) ProtoMessage() {}
func (*RolloutList) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{85}
}
func (m *RolloutList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutList) 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 *RolloutList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutList.Merge(m, src)
}
func (m *RolloutList) XXX_Size() int {
	return m.Size()
}
func (m *RolloutList) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutList.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutList proto.InternalMessageInfo

func (m *RolloutPause) Reset()      { *m = RolloutPause{} }
func (*RolloutPause) ProtoMessage() {}
func (*RolloutPause) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{86}
}
func (m *RolloutPause) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutPause) 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 *RolloutPause) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutPause.Merge(m, src)
}
func (m *RolloutPause) XXX_Size() int {
	return m.Size()
}
func (m *RolloutPause) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutPause.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutPause proto.InternalMessageInfo

func (m *RolloutSpec) Reset()      { *m = RolloutSpec{} }
func (*RolloutSpec) ProtoMessage() {}
func (*RolloutSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{87}
}
func (m *RolloutSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutSpec) 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 *RolloutSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutSpec.Merge(m, src)
}
func (m *RolloutSpec) XXX_Size() int {
	return m.Size()
}
func (m *RolloutSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutSpec.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutSpec proto.InternalMessageInfo

func (m *RolloutStatus) Reset()      { *m = RolloutStatus{} }
func (*RolloutStatus) ProtoMessage() {}
func (*RolloutStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{88}
}
func (m *RolloutStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutStatus) 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 *RolloutStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutStatus.Merge(m, src)
}
func (m *RolloutStatus) XXX_Size() int {
	return m.Size()
}
func (m *RolloutStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutStatus.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutStatus proto.InternalMessageInfo

func (m *RolloutStrategy) Reset()      { *m = RolloutStrategy{} }
func (*RolloutStrategy) ProtoMessage() {}
func (*RolloutStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{89}
}
func (m *RolloutStrategy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutStrategy) 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 *RolloutStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutStrategy.Merge(m, src)
}
func (m *RolloutStrategy) XXX_Size() int {
	return m.Size()
}
func (m *RolloutStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutStrategy proto.InternalMessageInfo

func (m *RolloutTrafficRouting) Reset()      { *m = RolloutTrafficRouting{} }
func (*RolloutTrafficRouting) ProtoMessage() {}
func (*RolloutTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{90}
}
func (m *RolloutTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RolloutTrafficRouting) 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 *RolloutTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RolloutTrafficRouting.Merge(m, src)
}
func (m *RolloutTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *RolloutTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_RolloutTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_RolloutTrafficRouting proto.InternalMessageInfo

func (m *RouteMatch) Reset()      { *m = RouteMatch{} }
func (*RouteMatch) ProtoMessage() {}
func (*RouteMatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{91}
}
func (m *RouteMatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RouteMatch) 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 *RouteMatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RouteMatch.Merge(m, src)
}
func (m *RouteMatch) XXX_Size() int {
	return m.Size()
}
func (m *RouteMatch) XXX_DiscardUnknown() {
	xxx_messageInfo_RouteMatch.DiscardUnknown(m)
}

var xxx_messageInfo_RouteMatch proto.InternalMessageInfo

func (m *RunSummary) Reset()      { *m = RunSummary{} }
func (*RunSummary) ProtoMessage() {}
func (*RunSummary) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{92}
}
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 *SMITrafficRouting) Reset()      { *m = SMITrafficRouting{} }
func (*SMITrafficRouting) ProtoMessage() {}
func (*SMITrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{93}
}
func (m *SMITrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SMITrafficRouting) 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 *SMITrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SMITrafficRouting.Merge(m, src)
}
func (m *SMITrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *SMITrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_SMITrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_SMITrafficRouting proto.InternalMessageInfo

func (m *ScopeDetail) Reset()      { *m = ScopeDetail{} }
func (*ScopeDetail) ProtoMessage() {}
func (*ScopeDetail) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{94}
}
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_e0e705f843545fab, []int{95}
}
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 *SecretRef) Reset()      { *m = SecretRef{} }
func (*SecretRef) ProtoMessage() {}
func (*SecretRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{96}
}
func (m *SecretRef) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SecretRef) 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 *SecretRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SecretRef.Merge(m, src)
}
func (m *SecretRef) XXX_Size() int {
	return m.Size()
}
func (m *SecretRef) XXX_DiscardUnknown() {
	xxx_messageInfo_SecretRef.DiscardUnknown(m)
}

var xxx_messageInfo_SecretRef proto.InternalMessageInfo

func (m *SetCanaryScale) Reset()      { *m = SetCanaryScale{} }
func (*SetCanaryScale) ProtoMessage() {}
func (*SetCanaryScale) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{97}
}
func (m *SetCanaryScale) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetCanaryScale) 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 *SetCanaryScale) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetCanaryScale.Merge(m, src)
}
func (m *SetCanaryScale) XXX_Size() int {
	return m.Size()
}
func (m *SetCanaryScale) XXX_DiscardUnknown() {
	xxx_messageInfo_SetCanaryScale.DiscardUnknown(m)
}

var xxx_messageInfo_SetCanaryScale proto.InternalMessageInfo

func (m *SetHeaderRoute) Reset()      { *m = SetHeaderRoute{} }
func (*SetHeaderRoute) ProtoMessage() {}
func (*SetHeaderRoute) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{98}
}
func (m *SetHeaderRoute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetHeaderRoute) 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 *SetHeaderRoute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetHeaderRoute.Merge(m, src)
}
func (m *SetHeaderRoute) XXX_Size() int {
	return m.Size()
}
func (m *SetHeaderRoute) XXX_DiscardUnknown() {
	xxx_messageInfo_SetHeaderRoute.DiscardUnknown(m)
}

var xxx_messageInfo_SetHeaderRoute proto.InternalMessageInfo

func (m *SetMirrorRoute) Reset()      { *m = SetMirrorRoute{} }
func (*SetMirrorRoute) ProtoMessage() {}
func (*SetMirrorRoute) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{99}
}
func (m *SetMirrorRoute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetMirrorRoute) 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 *SetMirrorRoute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetMirrorRoute.Merge(m, src)
}
func (m *SetMirrorRoute) XXX_Size() int {
	return m.Size()
}
func (m *SetMirrorRoute) XXX_DiscardUnknown() {
	xxx_messageInfo_SetMirrorRoute.DiscardUnknown(m)
}

var xxx_messageInfo_SetMirrorRoute proto.InternalMessageInfo

func (m *Sigv4Config) Reset()      { *m = Sigv4Config{} }
func (*Sigv4Config) ProtoMessage() {}
func (*Sigv4Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{100}
}
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_e0e705f843545fab, []int{101}
}
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 *StepPluginStatus) Reset()      { *m = StepPluginStatus{} }
func (*StepPluginStatus) ProtoMessage() {}
func (*StepPluginStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{102}
}
func (m *StepPluginStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StepPluginStatus) 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 *StepPluginStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StepPluginStatus.Merge(m, src)
}
func (m *StepPluginStatus) XXX_Size() int {
	return m.Size()
}
func (m *StepPluginStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_StepPluginStatus.DiscardUnknown(m)
}

var xxx_messageInfo_StepPluginStatus proto.InternalMessageInfo

func (m *StickinessConfig) Reset()      { *m = StickinessConfig{} }
func (*StickinessConfig) ProtoMessage() {}
func (*StickinessConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{103}
}
func (m *StickinessConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StickinessConfig) 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 *StickinessConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StickinessConfig.Merge(m, src)
}
func (m *StickinessConfig) XXX_Size() int {
	return m.Size()
}
func (m *StickinessConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_StickinessConfig.DiscardUnknown(m)
}

var xxx_messageInfo_StickinessConfig proto.InternalMessageInfo

func (m *StringMatch) Reset()      { *m = StringMatch{} }
func (*StringMatch) ProtoMessage() {}
func (*StringMatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{104}
}
func (m *StringMatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StringMatch) 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 *StringMatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringMatch.Merge(m, src)
}
func (m *StringMatch) XXX_Size() int {
	return m.Size()
}
func (m *StringMatch) XXX_DiscardUnknown() {
	xxx_messageInfo_StringMatch.DiscardUnknown(m)
}

var xxx_messageInfo_StringMatch proto.InternalMessageInfo

func (m *TCPRoute) Reset()      { *m = TCPRoute{} }
func (*TCPRoute) ProtoMessage() {}
func (*TCPRoute) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{105}
}
func (m *TCPRoute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TCPRoute) 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 *TCPRoute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TCPRoute.Merge(m, src)
}
func (m *TCPRoute) XXX_Size() int {
	return m.Size()
}
func (m *TCPRoute) XXX_DiscardUnknown() {
	xxx_messageInfo_TCPRoute.DiscardUnknown(m)
}

var xxx_messageInfo_TCPRoute proto.InternalMessageInfo

func (m *TLSRoute) Reset()      { *m = TLSRoute{} }
func (*TLSRoute) ProtoMessage() {}
func (*TLSRoute) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{106}
}
func (m *TLSRoute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLSRoute) 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 *TLSRoute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLSRoute.Merge(m, src)
}
func (m *TLSRoute) XXX_Size() int {
	return m.Size()
}
func (m *TLSRoute) XXX_DiscardUnknown() {
	xxx_messageInfo_TLSRoute.DiscardUnknown(m)
}

var xxx_messageInfo_TLSRoute proto.InternalMessageInfo

func (m *TTLStrategy) Reset()      { *m = TTLStrategy{} }
func (*TTLStrategy) ProtoMessage() {}
func (*TTLStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{107}
}
func (m *TTLStrategy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TTLStrategy) 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 *TTLStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TTLStrategy.Merge(m, src)
}
func (m *TTLStrategy) XXX_Size() int {
	return m.Size()
}
func (m *TTLStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_TTLStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_TTLStrategy proto.InternalMessageInfo

func (m *TemplateService) Reset()      { *m = TemplateService{} }
func (*TemplateService) ProtoMessage() {}
func (*TemplateService) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{108}
}
func (m *TemplateService) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TemplateService) 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 *TemplateService) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TemplateService.Merge(m, src)
}
func (m *TemplateService) XXX_Size() int {
	return m.Size()
}
func (m *TemplateService) XXX_DiscardUnknown() {
	xxx_messageInfo_TemplateService.DiscardUnknown(m)
}

var xxx_messageInfo_TemplateService proto.InternalMessageInfo

func (m *TemplateSpec) Reset()      { *m = TemplateSpec{} }
func (*TemplateSpec) ProtoMessage() {}
func (*TemplateSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{109}
}
func (m *TemplateSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TemplateSpec) 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 *TemplateSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TemplateSpec.Merge(m, src)
}
func (m *TemplateSpec) XXX_Size() int {
	return m.Size()
}
func (m *TemplateSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_TemplateSpec.DiscardUnknown(m)
}

var xxx_messageInfo_TemplateSpec proto.InternalMessageInfo

func (m *TemplateStatus) Reset()      { *m = TemplateStatus{} }
func (*TemplateStatus) ProtoMessage() {}
func (*TemplateStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{110}
}
func (m *TemplateStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TemplateStatus) 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 *TemplateStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TemplateStatus.Merge(m, src)
}
func (m *TemplateStatus) XXX_Size() int {
	return m.Size()
}
func (m *TemplateStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_TemplateStatus.DiscardUnknown(m)
}

var xxx_messageInfo_TemplateStatus proto.InternalMessageInfo

func (m *TraefikTrafficRouting) Reset()      { *m = TraefikTrafficRouting{} }
func (*TraefikTrafficRouting) ProtoMessage() {}
func (*TraefikTrafficRouting) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{111}
}
func (m *TraefikTrafficRouting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TraefikTrafficRouting) 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 *TraefikTrafficRouting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TraefikTrafficRouting.Merge(m, src)
}
func (m *TraefikTrafficRouting) XXX_Size() int {
	return m.Size()
}
func (m *TraefikTrafficRouting) XXX_DiscardUnknown() {
	xxx_messageInfo_TraefikTrafficRouting.DiscardUnknown(m)
}

var xxx_messageInfo_TraefikTrafficRouting proto.InternalMessageInfo

func (m *TrafficWeights) Reset()      { *m = TrafficWeights{} }
func (*TrafficWeights) ProtoMessage() {}
func (*TrafficWeights) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{112}
}
func (m *TrafficWeights) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TrafficWeights) 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 *TrafficWeights) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrafficWeights.Merge(m, src)
}
func (m *TrafficWeights) XXX_Size() int {
	return m.Size()
}
func (m *TrafficWeights) XXX_DiscardUnknown() {
	xxx_messageInfo_TrafficWeights.DiscardUnknown(m)
}

var xxx_messageInfo_TrafficWeights proto.InternalMessageInfo

func (m *ValueFrom) Reset()      { *m = ValueFrom{} }
func (*ValueFrom) ProtoMessage() {}
func (*ValueFrom) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{113}
}
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_e0e705f843545fab, []int{114}
}
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_e0e705f843545fab, []int{115}
}
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_e0e705f843545fab, []int{116}
}
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 (m *WeightDestination) Reset()      { *m = WeightDestination{} }
func (*WeightDestination) ProtoMessage() {}
func (*WeightDestination) Descriptor() ([]byte, []int) {
	return fileDescriptor_e0e705f843545fab, []int{117}
}
func (m *WeightDestination) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WeightDestination) 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 *WeightDestination) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WeightDestination.Merge(m, src)
}
func (m *WeightDestination) XXX_Size() int {
	return m.Size()
}
func (m *WeightDestination) XXX_DiscardUnknown() {
	xxx_messageInfo_WeightDestination.DiscardUnknown(m)
}

var xxx_messageInfo_WeightDestination proto.InternalMessageInfo

func init() {
	proto.RegisterType((*ALBStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ALBStatus")
	proto.RegisterType((*ALBTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ALBTrafficRouting")
	proto.RegisterType((*AmbassadorTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AmbassadorTrafficRouting")
	proto.RegisterType((*AnalysisRun)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRun")
	proto.RegisterType((*AnalysisRunArgument)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunArgument")
	proto.RegisterType((*AnalysisRunList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunList")
	proto.RegisterType((*AnalysisRunMetadata)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunMetadata")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunMetadata.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunMetadata.LabelsEntry")
	proto.RegisterType((*AnalysisRunSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunSpec")
	proto.RegisterType((*AnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunStatus")
	proto.RegisterType((*AnalysisRunStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunStrategy")
	proto.RegisterType((*AnalysisTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplate")
	proto.RegisterType((*AnalysisTemplateList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplateList")
	proto.RegisterType((*AnalysisTemplateRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplateRef")
	proto.RegisterType((*AnalysisTemplateSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplateSpec")
	proto.RegisterType((*AntiAffinity)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AntiAffinity")
	proto.RegisterType((*ApisixRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ApisixRoute")
	proto.RegisterType((*ApisixTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ApisixTrafficRouting")
	proto.RegisterType((*AppMeshTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshTrafficRouting")
	proto.RegisterType((*AppMeshVirtualNodeGroup)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualNodeGroup")
	proto.RegisterType((*AppMeshVirtualNodeReference)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualNodeReference")
	proto.RegisterType((*AppMeshVirtualService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualService")
	proto.RegisterType((*Argument)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Argument")
	proto.RegisterType((*ArgumentValueFrom)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ArgumentValueFrom")
	proto.RegisterType((*Authentication)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Authentication")
	proto.RegisterType((*AwsResourceRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AwsResourceRef")
	proto.RegisterType((*BlueGreenStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.BlueGreenStatus")
	proto.RegisterType((*BlueGreenStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.BlueGreenStrategy")
	proto.RegisterType((*CanaryStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CanaryStatus")
	proto.RegisterType((*CanaryStep)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CanaryStep")
	proto.RegisterType((*CanaryStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CanaryStrategy")
	proto.RegisterType((*CloudWatchMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetric")
	proto.RegisterType((*CloudWatchMetricDataQuery)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricDataQuery")
	proto.RegisterType((*CloudWatchMetricStat)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricStat")
	proto.RegisterType((*CloudWatchMetricStatMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricStatMetric")
	proto.RegisterType((*CloudWatchMetricStatMetricDimension)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricStatMetricDimension")
	proto.RegisterType((*ClusterAnalysisTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ClusterAnalysisTemplate")
	proto.RegisterType((*ClusterAnalysisTemplateList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ClusterAnalysisTemplateList")
	proto.RegisterType((*DatadogMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DatadogMetric")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DatadogMetric.QueriesEntry")
	proto.RegisterType((*DryRun)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DryRun")
	proto.RegisterType((*Experiment)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Experiment")
	proto.RegisterType((*ExperimentAnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentAnalysisRunStatus")
	proto.RegisterType((*ExperimentAnalysisTemplateRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentAnalysisTemplateRef")
	proto.RegisterType((*ExperimentCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentCondition")
	proto.RegisterType((*ExperimentList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentList")
	proto.RegisterType((*ExperimentSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentSpec")
	proto.RegisterType((*ExperimentStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentStatus")
	proto.RegisterType((*FieldRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.FieldRef")
	proto.RegisterType((*GraphiteMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.GraphiteMetric")
	proto.RegisterType((*HeaderRoutingMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.HeaderRoutingMatch")
	proto.RegisterType((*InfluxdbMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.InfluxdbMetric")
	proto.RegisterType((*IstioDestinationRule)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.IstioDestinationRule")
	proto.RegisterType((*IstioTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.IstioTrafficRouting")
	proto.RegisterType((*IstioVirtualService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.IstioVirtualService")
	proto.RegisterType((*JobMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.JobMetric")
	proto.RegisterType((*KayentaMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.KayentaMetric")
	proto.RegisterType((*KayentaScope)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.KayentaScope")
	proto.RegisterType((*KayentaThreshold)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.KayentaThreshold")
	proto.RegisterType((*MangedRoutes)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MangedRoutes")
	proto.RegisterType((*Measurement)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Measurement")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Measurement.MetadataEntry")
	proto.RegisterType((*MeasurementRetention)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MeasurementRetention")
	proto.RegisterType((*Metric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Metric")
	proto.RegisterType((*MetricProvider)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricProvider")
	proto.RegisterMapType((map[string]encoding_json.RawMessage)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricProvider.PluginEntry")
	proto.RegisterType((*MetricResult)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricResult")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricResult.MetadataEntry")
	proto.RegisterType((*NewRelicMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NewRelicMetric")
	proto.RegisterType((*NginxTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting.AdditionalIngressAnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting.CanaryIngressAnnotationsEntry")
	proto.RegisterType((*OAuth2Config)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.OAuth2Config")
	proto.RegisterType((*ObjectRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ObjectRef")
	proto.RegisterType((*PauseCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PauseCondition")
	proto.RegisterType((*PingPongSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PingPongSpec")
	proto.RegisterType((*PluginStep)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PluginStep")
	proto.RegisterType((*PodTemplateMetadata)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata.LabelsEntry")
	proto.RegisterType((*PreferredDuringSchedulingIgnoredDuringExecution)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution")
	proto.RegisterType((*PrometheusMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PrometheusMetric")
	proto.RegisterType((*PrometheusRangeQueryArgs)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PrometheusRangeQueryArgs")
	proto.RegisterType((*ReplicaProgressThreshold)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ReplicaProgressThreshold")
	proto.RegisterType((*RequiredDuringSchedulingIgnoredDuringExecution)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution")
	proto.RegisterType((*RollbackWindowSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RollbackWindowSpec")
	proto.RegisterType((*Rollout)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Rollout")
	proto.RegisterType((*RolloutAnalysis)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysis")
	proto.RegisterType((*RolloutAnalysisBackground)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysisBackground")
	proto.RegisterType((*RolloutAnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysisRunStatus")
	proto.RegisterType((*RolloutCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutCondition")
	proto.RegisterType((*RolloutExperimentStep)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutExperimentStep")
	proto.RegisterType((*RolloutExperimentStepAnalysisTemplateRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutExperimentStepAnalysisTemplateRef")
	proto.RegisterType((*RolloutExperimentTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutExperimentTemplate")
	proto.RegisterType((*RolloutList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutList")
	proto.RegisterType((*RolloutPause)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutPause")
	proto.RegisterType((*RolloutSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutSpec")
	proto.RegisterType((*RolloutStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutStatus")
	proto.RegisterType((*RolloutStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutStrategy")
	proto.RegisterType((*RolloutTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutTrafficRouting")
	proto.RegisterMapType((map[string]encoding_json.RawMessage)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutTrafficRouting.PluginsEntry")
	proto.RegisterType((*RouteMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RouteMatch")
	proto.RegisterMapType((map[string]StringMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RouteMatch.HeadersEntry")
	proto.RegisterType((*RunSummary)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RunSummary")
	proto.RegisterType((*SMITrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SMITrafficRouting")
	proto.RegisterType((*ScopeDetail)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ScopeDetail")
	proto.RegisterType((*SecretKeyRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SecretKeyRef")
	proto.RegisterType((*SecretRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SecretRef")
	proto.RegisterType((*SetCanaryScale)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SetCanaryScale")
	proto.RegisterType((*SetHeaderRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SetHeaderRoute")
	proto.RegisterType((*SetMirrorRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SetMirrorRoute")
	proto.RegisterType((*Sigv4Config)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Sigv4Config")
	proto.RegisterType((*SkyWalkingMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SkyWalkingMetric")
	proto.RegisterType((*StepPluginStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.StepPluginStatus")
	proto.RegisterType((*StickinessConfig)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.StickinessConfig")
	proto.RegisterType((*StringMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.StringMatch")
	proto.RegisterType((*TCPRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TCPRoute")
	proto.RegisterType((*TLSRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TLSRoute")
	proto.RegisterType((*TTLStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TTLStrategy")
	proto.RegisterType((*TemplateService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TemplateService")
	proto.RegisterType((*TemplateSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TemplateSpec")
	proto.RegisterType((*TemplateStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TemplateStatus")
	proto.RegisterType((*TraefikTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TraefikTrafficRouting")
	proto.RegisterType((*TrafficWeights)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TrafficWeights")
	proto.RegisterType((*ValueFrom)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ValueFrom")
	proto.RegisterType((*WavefrontMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WavefrontMetric")
	proto.RegisterType((*WebMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WebMetric")
	proto.RegisterType((*WebMetricHeader)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WebMetricHeader")
	proto.RegisterType((*WeightDestination)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WeightDestination")
}

func init() {
	proto.RegisterFile("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.proto", fileDescriptor_e0e705f843545fab)
}

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

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

func (m *ALBStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Ingress)
	copy(dAtA[i:], m.Ingress)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Ingress)))
	i--
	dAtA[i] = 0x22
	{
		size, err := m.StableTargetGroup.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.CanaryTargetGroup.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.LoadBalancer.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 *ALBTrafficRouting) 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 *ALBTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ALBTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ingresses) > 0 {
		for iNdEx := len(m.Ingresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ingresses[iNdEx])
			copy(dAtA[i:], m.Ingresses[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Ingresses[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.StickinessConfig != nil {
		{
			size, err := m.StickinessConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	i -= len(m.AnnotationPrefix)
	copy(dAtA[i:], m.AnnotationPrefix)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.AnnotationPrefix)))
	i--
	dAtA[i] = 0x22
	i -= len(m.RootService)
	copy(dAtA[i:], m.RootService)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RootService)))
	i--
	dAtA[i] = 0x1a
	i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort))
	i--
	dAtA[i] = 0x10
	i -= len(m.Ingress)
	copy(dAtA[i:], m.Ingress)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Ingress)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *AnalysisRunMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		keysForAnnotations := make([]string, 0, len(m.Annotations))
		for k := range m.Annotations {
			keysForAnnotations = append(keysForAnnotations, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
		for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Annotations[string(keysForAnnotations[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForAnnotations[iNdEx])
			copy(dAtA[i:], keysForAnnotations[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Labels) > 0 {
		keysForLabels := make([]string, 0, len(m.Labels))
		for k := range m.Labels {
			keysForLabels = append(keysForLabels, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
		for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Labels[string(keysForLabels[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForLabels[iNdEx])
			copy(dAtA[i:], keysForLabels[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			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 m.TTLStrategy != nil {
		{
			size, err := m.TTLStrategy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	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.CompletedAt != nil {
		{
			size, err := m.CompletedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	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 *AnalysisRunStrategy) 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 *AnalysisRunStrategy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisRunStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UnsuccessfulRunHistoryLimit != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.UnsuccessfulRunHistoryLimit))
		i--
		dAtA[i] = 0x10
	}
	if m.SuccessfulRunHistoryLimit != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.SuccessfulRunHistoryLimit))
		i--
		dAtA[i] = 0x8
	}
	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 *AnalysisTemplateRef) 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 *AnalysisTemplateRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AnalysisTemplateRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.ClusterScope {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x10
	i -= len(m.TemplateName)
	copy(dAtA[i:], m.TemplateName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TemplateName)))
	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.Templates) > 0 {
		for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Templates[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.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 *AntiAffinity) 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 *AntiAffinity) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AntiAffinity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RequiredDuringSchedulingIgnoredDuringExecution != nil {
		{
			size, err := m.RequiredDuringSchedulingIgnoredDuringExecution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.PreferredDuringSchedulingIgnoredDuringExecution != nil {
		{
			size, err := m.PreferredDuringSchedulingIgnoredDuringExecution.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 *ApisixRoute) 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 *ApisixRoute) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApisixRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Rules) > 0 {
		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Rules[iNdEx])
			copy(dAtA[i:], m.Rules[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rules[iNdEx])))
			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 *ApisixTrafficRouting) 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 *ApisixTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApisixTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Route != nil {
		{
			size, err := m.Route.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 *AppMeshTrafficRouting) 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 *AppMeshTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AppMeshTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VirtualNodeGroup != nil {
		{
			size, err := m.VirtualNodeGroup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.VirtualService != nil {
		{
			size, err := m.VirtualService.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 *AppMeshVirtualNodeGroup) 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 *AppMeshVirtualNodeGroup) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AppMeshVirtualNodeGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StableVirtualNodeRef != nil {
		{
			size, err := m.StableVirtualNodeRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.CanaryVirtualNodeRef != nil {
		{
			size, err := m.CanaryVirtualNodeRef.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 *AppMeshVirtualNodeReference) 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 *AppMeshVirtualNodeReference) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AppMeshVirtualNodeReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *AppMeshVirtualService) 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 *AppMeshVirtualService) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AppMeshVirtualService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Routes) > 0 {
		for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Routes[iNdEx])
			copy(dAtA[i:], m.Routes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Routes[iNdEx])))
			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 *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 *ArgumentValueFrom) 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 *ArgumentValueFrom) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ArgumentValueFrom) 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.PodTemplateHashValue != nil {
		i -= len(*m.PodTemplateHashValue)
		copy(dAtA[i:], *m.PodTemplateHashValue)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PodTemplateHashValue)))
		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 *AwsResourceRef) 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 *AwsResourceRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AwsResourceRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.FullName)
	copy(dAtA[i:], m.FullName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FullName)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.ARN)
	copy(dAtA[i:], m.ARN)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ARN)))
	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 *BlueGreenStatus) 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 *BlueGreenStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlueGreenStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PostPromotionAnalysisRunStatus != nil {
		{
			size, err := m.PostPromotionAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.PrePromotionAnalysisRunStatus != nil {
		{
			size, err := m.PrePromotionAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	i--
	if m.ScaleUpPreviewCheckPoint {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	i -= len(m.ActiveSelector)
	copy(dAtA[i:], m.ActiveSelector)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ActiveSelector)))
	i--
	dAtA[i] = 0x12
	i -= len(m.PreviewSelector)
	copy(dAtA[i:], m.PreviewSelector)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PreviewSelector)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *BlueGreenStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AbortScaleDownDelaySeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.AbortScaleDownDelaySeconds))
		i--
		dAtA[i] = 0x70
	}
	if m.ActiveMetadata != nil {
		{
			size, err := m.ActiveMetadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.PreviewMetadata != nil {
		{
			size, err := m.PreviewMetadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.PostPromotionAnalysis != nil {
		{
			size, err := m.PostPromotionAnalysis.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.AntiAffinity != nil {
		{
			size, err := m.AntiAffinity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.PrePromotionAnalysis != nil {
		{
			size, err := m.PrePromotionAnalysis.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.ScaleDownDelayRevisionLimit != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelayRevisionLimit))
		i--
		dAtA[i] = 0x40
	}
	if m.ScaleDownDelaySeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds))
		i--
		dAtA[i] = 0x38
	}
	if m.MaxUnavailable != nil {
		{
			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.AutoPromotionSeconds))
	i--
	dAtA[i] = 0x28
	if m.AutoPromotionEnabled != nil {
		i--
		if *m.AutoPromotionEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.PreviewReplicaCount != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.PreviewReplicaCount))
		i--
		dAtA[i] = 0x18
	}
	i -= len(m.PreviewService)
	copy(dAtA[i:], m.PreviewService)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PreviewService)))
	i--
	dAtA[i] = 0x12
	i -= len(m.ActiveService)
	copy(dAtA[i:], m.ActiveService)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ActiveService)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *CanaryStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.StepPluginStatuses) > 0 {
		for iNdEx := len(m.StepPluginStatuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StepPluginStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	i -= len(m.StablePingPong)
	copy(dAtA[i:], m.StablePingPong)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StablePingPong)))
	i--
	dAtA[i] = 0x2a
	if m.Weights != nil {
		{
			size, err := m.Weights.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	i -= len(m.CurrentExperiment)
	copy(dAtA[i:], m.CurrentExperiment)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentExperiment)))
	i--
	dAtA[i] = 0x1a
	if m.CurrentBackgroundAnalysisRunStatus != nil {
		{
			size, err := m.CurrentBackgroundAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.CurrentStepAnalysisRunStatus != nil {
		{
			size, err := m.CurrentStepAnalysisRunStatus.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 *CanaryStep) 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 *CanaryStep) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CanaryStep) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Plugin != nil {
		{
			size, err := m.Plugin.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.SetMirrorRoute != nil {
		{
			size, err := m.SetMirrorRoute.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.SetHeaderRoute != nil {
		{
			size, err := m.SetHeaderRoute.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.SetCanaryScale != nil {
		{
			size, err := m.SetCanaryScale.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Analysis != nil {
		{
			size, err := m.Analysis.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Experiment != nil {
		{
			size, err := m.Experiment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Pause != nil {
		{
			size, err := m.Pause.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.SetWeight != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.SetWeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CanaryStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReplicaProgressThreshold != nil {
		{
			size, err := m.ReplicaProgressThreshold.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.MinPodsPerReplicaSet != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.MinPodsPerReplicaSet))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.PingPong != nil {
		{
			size, err := m.PingPong.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	i--
	if m.DynamicStableScale {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x70
	if m.AbortScaleDownDelaySeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.AbortScaleDownDelaySeconds))
		i--
		dAtA[i] = 0x68
	}
	if m.ScaleDownDelayRevisionLimit != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelayRevisionLimit))
		i--
		dAtA[i] = 0x60
	}
	if m.ScaleDownDelaySeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds))
		i--
		dAtA[i] = 0x58
	}
	if m.StableMetadata != nil {
		{
			size, err := m.StableMetadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.CanaryMetadata != nil {
		{
			size, err := m.CanaryMetadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.AntiAffinity != nil {
		{
			size, err := m.AntiAffinity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Analysis != nil {
		{
			size, err := m.Analysis.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.MaxSurge != nil {
		{
			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.MaxUnavailable != nil {
		{
			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.TrafficRouting != nil {
		{
			size, err := m.TrafficRouting.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Steps) > 0 {
		for iNdEx := len(m.Steps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Steps[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.StableService)
	copy(dAtA[i:], m.StableService)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableService)))
	i--
	dAtA[i] = 0x12
	i -= len(m.CanaryService)
	copy(dAtA[i:], m.CanaryService)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CanaryService)))
	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 *ClusterAnalysisTemplate) 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 *ClusterAnalysisTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ClusterAnalysisTemplateList) 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 *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
	{
		size, err := m.SecretRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	i -= len(m.Aggregator)
	copy(dAtA[i:], m.Aggregator)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Aggregator)))
	i--
	dAtA[i] = 0x32
	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 *Experiment) 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 *Experiment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ExperimentAnalysisRunStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x22
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.AnalysisRun)
	copy(dAtA[i:], m.AnalysisRun)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.AnalysisRun)))
	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 *ExperimentAnalysisTemplateRef) 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 *ExperimentAnalysisTemplateRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExperimentAnalysisTemplateRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.RequiredForCompletion {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x28
	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] = 0x22
		}
	}
	i--
	if m.ClusterScope {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	i -= len(m.TemplateName)
	copy(dAtA[i:], m.TemplateName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TemplateName)))
	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 *ExperimentCondition) 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 *ExperimentCondition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExperimentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x32
	i -= len(m.Reason)
	copy(dAtA[i:], m.Reason)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	i -= len(m.Status)
	copy(dAtA[i:], m.Status)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ExperimentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.AnalysisRunMetadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	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] = 0x42
		}
	}
	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] = 0x3a
		}
	}
	if m.ScaleDownDelaySeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Analyses) > 0 {
		for iNdEx := len(m.Analyses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Analyses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	i--
	if m.Terminate {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	if m.ProgressDeadlineSeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
		i--
		dAtA[i] = 0x18
	}
	i -= len(m.Duration)
	copy(dAtA[i:], m.Duration)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Duration)))
	i--
	dAtA[i] = 0x12
	if len(m.Templates) > 0 {
		for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Templates[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 *ExperimentStatus) 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 *ExperimentStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExperimentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AnalysisRuns) > 0 {
		for iNdEx := len(m.AnalysisRuns) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AnalysisRuns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.AvailableAt != nil {
		{
			size, err := m.AvailableAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.TemplateStatuses) > 0 {
		for iNdEx := len(m.TemplateStatuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TemplateStatuses[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 *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 *HeaderRoutingMatch) 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 *HeaderRoutingMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeaderRoutingMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.HeaderValue != nil {
		{
			size, err := m.HeaderValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.HeaderName)
	copy(dAtA[i:], m.HeaderName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.HeaderName)))
	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 *IstioDestinationRule) 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 *IstioDestinationRule) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IstioDestinationRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AdditionalSubsetNames) > 0 {
		for iNdEx := len(m.AdditionalSubsetNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.AdditionalSubsetNames[iNdEx])
			copy(dAtA[i:], m.AdditionalSubsetNames[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.AdditionalSubsetNames[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	i -= len(m.StableSubsetName)
	copy(dAtA[i:], m.StableSubsetName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableSubsetName)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.CanarySubsetName)
	copy(dAtA[i:], m.CanarySubsetName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CanarySubsetName)))
	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 *IstioTrafficRouting) 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 *IstioTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IstioTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VirtualServices) > 0 {
		for iNdEx := len(m.VirtualServices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VirtualServices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.DestinationRule != nil {
		{
			size, err := m.DestinationRule.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.VirtualService != nil {
		{
			size, err := m.VirtualService.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 *IstioVirtualService) 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 *IstioVirtualService) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IstioVirtualService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TCPRoutes) > 0 {
		for iNdEx := len(m.TCPRoutes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TCPRoutes[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.TLSRoutes) > 0 {
		for iNdEx := len(m.TLSRoutes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TLSRoutes[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.Routes) > 0 {
		for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Routes[iNdEx])
			copy(dAtA[i:], m.Routes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Routes[iNdEx])))
			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 *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
	i--
	if m.Lookback {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x48
	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 *MangedRoutes) 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 *MangedRoutes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MangedRoutes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *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
	if m.ConsecutiveSuccessLimit != nil {
		{
			size, err := m.ConsecutiveSuccessLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	{
		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
	i = encodeVarintGenerated(dAtA, i, uint64(m.ConsecutiveSuccess))
	i--
	dAtA[i] = 0x68
	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
	if m.Timeout != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Timeout))
		i--
		dAtA[i] = 0x18
	}
	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 *NginxTrafficRouting) 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 *NginxTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NginxTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CanaryIngressAnnotations) > 0 {
		keysForCanaryIngressAnnotations := make([]string, 0, len(m.CanaryIngressAnnotations))
		for k := range m.CanaryIngressAnnotations {
			keysForCanaryIngressAnnotations = append(keysForCanaryIngressAnnotations, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForCanaryIngressAnnotations)
		for iNdEx := len(keysForCanaryIngressAnnotations) - 1; iNdEx >= 0; iNdEx-- {
			v := m.CanaryIngressAnnotations[string(keysForCanaryIngressAnnotations[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForCanaryIngressAnnotations[iNdEx])
			copy(dAtA[i:], keysForCanaryIngressAnnotations[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForCanaryIngressAnnotations[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.StableIngresses) > 0 {
		for iNdEx := len(m.StableIngresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.StableIngresses[iNdEx])
			copy(dAtA[i:], m.StableIngresses[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableIngresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.AdditionalIngressAnnotations) > 0 {
		keysForAdditionalIngressAnnotations := make([]string, 0, len(m.AdditionalIngressAnnotations))
		for k := range m.AdditionalIngressAnnotations {
			keysForAdditionalIngressAnnotations = append(keysForAdditionalIngressAnnotations, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForAdditionalIngressAnnotations)
		for iNdEx := len(keysForAdditionalIngressAnnotations) - 1; iNdEx >= 0; iNdEx-- {
			v := m.AdditionalIngressAnnotations[string(keysForAdditionalIngressAnnotations[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForAdditionalIngressAnnotations[iNdEx])
			copy(dAtA[i:], keysForAdditionalIngressAnnotations[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAdditionalIngressAnnotations[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	i -= len(m.StableIngress)
	copy(dAtA[i:], m.StableIngress)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableIngress)))
	i--
	dAtA[i] = 0x12
	i -= len(m.AnnotationPrefix)
	copy(dAtA[i:], m.AnnotationPrefix)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.AnnotationPrefix)))
	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 *ObjectRef) 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 *ObjectRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

func (m *PluginStep) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Config != nil {
		i -= len(m.Config)
		copy(dAtA[i:], m.Config)
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Config)))
		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 *PodTemplateMetadata) 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 *PodTemplateMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodTemplateMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		keysForAnnotations := make([]string, 0, len(m.Annotations))
		for k := range m.Annotations {
			keysForAnnotations = append(keysForAnnotations, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
		for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Annotations[string(keysForAnnotations[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForAnnotations[iNdEx])
			copy(dAtA[i:], keysForAnnotations[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Labels) > 0 {
		keysForLabels := make([]string, 0, len(m.Labels))
		for k := range m.Labels {
			keysForLabels = append(keysForLabels, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
		for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Labels[string(keysForLabels[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForLabels[iNdEx])
			copy(dAtA[i:], keysForLabels[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *PreferredDuringSchedulingIgnoredDuringExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.Weight))
	i--
	dAtA[i] = 0x8
	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 m.RangeQuery != nil {
		{
			size, err := m.RangeQuery.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	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 *PrometheusRangeQueryArgs) 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 *PrometheusRangeQueryArgs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

func (m *RequiredDuringSchedulingIgnoredDuringExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *RolloutAnalysis) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.AnalysisRunMetadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	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.Templates) > 0 {
		for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Templates[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 *RolloutAnalysisBackground) 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 *RolloutAnalysisBackground) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutAnalysisBackground) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StartingStep != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.StartingStep))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.RolloutAnalysis.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 *RolloutAnalysisRunStatus) 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 *RolloutAnalysisRunStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutAnalysisRunStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Status)
	copy(dAtA[i:], m.Status)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
	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 *RolloutCondition) 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 *RolloutCondition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x32
	i -= len(m.Reason)
	copy(dAtA[i:], m.Reason)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	i -= len(m.Status)
	copy(dAtA[i:], m.Status)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *RolloutExperimentStep) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ScaleDownDelaySeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds))
		i--
		dAtA[i] = 0x30
	}
	{
		size, err := m.AnalysisRunMetadata.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
		}
	}
	if len(m.Analyses) > 0 {
		for iNdEx := len(m.Analyses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Analyses[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.Duration)
	copy(dAtA[i:], m.Duration)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Duration)))
	i--
	dAtA[i] = 0x12
	if len(m.Templates) > 0 {
		for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Templates[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 *RolloutExperimentStepAnalysisTemplateRef) 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 *RolloutExperimentStepAnalysisTemplateRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutExperimentStepAnalysisTemplateRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.RequiredForCompletion {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x28
	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] = 0x22
		}
	}
	i--
	if m.ClusterScope {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	i -= len(m.TemplateName)
	copy(dAtA[i:], m.TemplateName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TemplateName)))
	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 *RolloutExperimentTemplate) 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 *RolloutExperimentTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutExperimentTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Service != nil {
		{
			size, err := m.Service.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Weight != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Weight))
		i--
		dAtA[i] = 0x30
	}
	if m.Selector != nil {
		{
			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Replicas != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
		i--
		dAtA[i] = 0x18
	}
	i -= len(m.SpecRef)
	copy(dAtA[i:], m.SpecRef)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SpecRef)))
	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 *RolloutList) 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 *RolloutList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *RolloutPause) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Duration != nil {
		{
			size, err := m.Duration.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 *RolloutSpec) 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 *RolloutSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RollbackWindow != nil {
		{
			size, err := m.RollbackWindow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	i--
	if m.ProgressDeadlineAbort {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x60
	if m.Analysis != nil {
		{
			size, err := m.Analysis.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.WorkloadRef != nil {
		{
			size, err := m.WorkloadRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.RestartAt != nil {
		{
			size, err := m.RestartAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.ProgressDeadlineSeconds != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
		i--
		dAtA[i] = 0x40
	}
	i--
	if m.Paused {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x38
	if m.RevisionHistoryLimit != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
		i--
		dAtA[i] = 0x30
	}
	{
		size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
	i--
	dAtA[i] = 0x20
	{
		size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Selector != nil {
		{
			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Replicas != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *RolloutStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ALBs) > 0 {
		for iNdEx := len(m.ALBs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ALBs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xd2
		}
	}
	if m.ALB != nil {
		{
			size, err := m.ALB.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	i -= len(m.WorkloadObservedGeneration)
	copy(dAtA[i:], m.WorkloadObservedGeneration)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.WorkloadObservedGeneration)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xc2
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xba
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xb2
	i--
	if m.PromoteFull {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xa8
	if m.RestartedAt != nil {
		{
			size, err := m.RestartedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	i -= len(m.StableRS)
	copy(dAtA[i:], m.StableRS)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableRS)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x9a
	i -= len(m.Selector)
	copy(dAtA[i:], m.Selector)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Selector)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	i = encodeVarintGenerated(dAtA, i, uint64(m.HPAReplicas))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x88
	{
		size, err := m.BlueGreen.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size, err := m.Canary.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x72
		}
	}
	i -= len(m.ObservedGeneration)
	copy(dAtA[i:], m.ObservedGeneration)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ObservedGeneration)))
	i--
	dAtA[i] = 0x6a
	if m.CollisionCount != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
		i--
		dAtA[i] = 0x60
	}
	if m.CurrentStepIndex != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.CurrentStepIndex))
		i--
		dAtA[i] = 0x58
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
	i--
	dAtA[i] = 0x50
	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
	i--
	dAtA[i] = 0x48
	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
	i--
	dAtA[i] = 0x40
	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
	i--
	dAtA[i] = 0x38
	i -= len(m.CurrentStepHash)
	copy(dAtA[i:], m.CurrentStepHash)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentStepHash)))
	i--
	dAtA[i] = 0x32
	i -= len(m.CurrentPodHash)
	copy(dAtA[i:], m.CurrentPodHash)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentPodHash)))
	i--
	dAtA[i] = 0x2a
	if m.AbortedAt != nil {
		{
			size, err := m.AbortedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	i--
	if m.ControllerPause {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	if len(m.PauseConditions) > 0 {
		for iNdEx := len(m.PauseConditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PauseConditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	i--
	if m.Abort {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *RolloutStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Canary != nil {
		{
			size, err := m.Canary.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.BlueGreen != nil {
		{
			size, err := m.BlueGreen.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 *RolloutTrafficRouting) 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 *RolloutTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RolloutTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxTrafficWeight != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxTrafficWeight))
		i--
		dAtA[i] = 0x58
	}
	if len(m.Plugins) > 0 {
		keysForPlugins := make([]string, 0, len(m.Plugins))
		for k := range m.Plugins {
			keysForPlugins = append(keysForPlugins, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForPlugins)
		for iNdEx := len(keysForPlugins) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Plugins[string(keysForPlugins[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(keysForPlugins[iNdEx])
			copy(dAtA[i:], keysForPlugins[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPlugins[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.Apisix != nil {
		{
			size, err := m.Apisix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if len(m.ManagedRoutes) > 0 {
		for iNdEx := len(m.ManagedRoutes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ManagedRoutes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.Traefik != nil {
		{
			size, err := m.Traefik.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.AppMesh != nil {
		{
			size, err := m.AppMesh.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Ambassador != nil {
		{
			size, err := m.Ambassador.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.SMI != nil {
		{
			size, err := m.SMI.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ALB != nil {
		{
			size, err := m.ALB.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Nginx != nil {
		{
			size, err := m.Nginx.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Istio != nil {
		{
			size, err := m.Istio.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 *RouteMatch) 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 *RouteMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RouteMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Headers) > 0 {
		keysForHeaders := make([]string, 0, len(m.Headers))
		for k := range m.Headers {
			keysForHeaders = append(keysForHeaders, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders)
		for iNdEx := len(keysForHeaders) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Headers[string(keysForHeaders[iNdEx])]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(keysForHeaders[iNdEx])
			copy(dAtA[i:], keysForHeaders[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForHeaders[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Path != nil {
		{
			size, err := m.Path.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Method != nil {
		{
			size, err := m.Method.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 *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 *SMITrafficRouting) 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 *SMITrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SMITrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.TrafficSplitName)
	copy(dAtA[i:], m.TrafficSplitName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TrafficSplitName)))
	i--
	dAtA[i] = 0x12
	i -= len(m.RootService)
	copy(dAtA[i:], m.RootService)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RootService)))
	i--
	dAtA[i] = 0xa
	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 *SecretRef) 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 *SecretRef) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SecretRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Namespaced {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x10
	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 *SetCanaryScale) 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 *SetCanaryScale) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetCanaryScale) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.MatchTrafficWeight {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	if m.Replicas != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
		i--
		dAtA[i] = 0x10
	}
	if m.Weight != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Weight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SetHeaderRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Match) > 0 {
		for iNdEx := len(m.Match) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Match[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.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 *SetMirrorRoute) 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 *SetMirrorRoute) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetMirrorRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Percentage != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Percentage))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Match) > 0 {
		for iNdEx := len(m.Match) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Match[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.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 *StepPluginStatus) 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 *StepPluginStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StepPluginStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x62
	}
	i--
	if m.Disabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x58
	i = encodeVarintGenerated(dAtA, i, uint64(m.Executions))
	i--
	dAtA[i] = 0x50
	i -= len(m.Backoff)
	copy(dAtA[i:], m.Backoff)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Backoff)))
	i--
	dAtA[i] = 0x4a
	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] = 0x42
	}
	if m.UpdatedAt != nil {
		{
			size, err := m.UpdatedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	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] = 0x32
	}
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x2a
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0x22
	i -= len(m.Operation)
	copy(dAtA[i:], m.Operation)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operation)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0x12
	i = encodeVarintGenerated(dAtA, i, uint64(m.Index))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *StickinessConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.DurationSeconds))
	i--
	dAtA[i] = 0x10
	i--
	if m.Enabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *TLSRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SNIHosts) > 0 {
		for iNdEx := len(m.SNIHosts) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SNIHosts[iNdEx])
			copy(dAtA[i:], m.SNIHosts[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.SNIHosts[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.Port))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *TTLStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SecondsAfterSuccess != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.SecondsAfterSuccess))
		i--
		dAtA[i] = 0x18
	}
	if m.SecondsAfterFailure != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.SecondsAfterFailure))
		i--
		dAtA[i] = 0x10
	}
	if m.SecondsAfterCompletion != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.SecondsAfterCompletion))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TemplateService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *TemplateSpec) 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 *TemplateSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TemplateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Service != nil {
		{
			size, err := m.Service.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	{
		size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.Selector != nil {
		{
			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
	i--
	dAtA[i] = 0x18
	if m.Replicas != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
		i--
		dAtA[i] = 0x10
	}
	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 *TemplateStatus) 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 *TemplateStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TemplateStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.PodTemplateHash)
	copy(dAtA[i:], m.PodTemplateHash)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodTemplateHash)))
	i--
	dAtA[i] = 0x5a
	i -= len(m.ServiceName)
	copy(dAtA[i:], m.ServiceName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
	i--
	dAtA[i] = 0x52
	if m.LastTransitionTime != nil {
		{
			size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x42
	i -= len(m.Status)
	copy(dAtA[i:], m.Status)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
	i--
	dAtA[i] = 0x3a
	if m.CollisionCount != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
		i--
		dAtA[i] = 0x30
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
	i--
	dAtA[i] = 0x28
	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
	i--
	dAtA[i] = 0x20
	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
	i--
	dAtA[i] = 0x18
	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
	i--
	dAtA[i] = 0x10
	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 *TraefikTrafficRouting) 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 *TraefikTrafficRouting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *TrafficWeights) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Verified != nil {
		i--
		if *m.Verified {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.Additional) > 0 {
		for iNdEx := len(m.Additional) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Additional[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.Stable.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Canary.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 *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 (m *WeightDestination) 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 *WeightDestination) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WeightDestination) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.PodTemplateHash)
	copy(dAtA[i:], m.PodTemplateHash)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodTemplateHash)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.ServiceName)
	copy(dAtA[i:], m.ServiceName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
	i--
	dAtA[i] = 0x12
	i = encodeVarintGenerated(dAtA, i, uint64(m.Weight))
	i--
	dAtA[i] = 0x8
	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 *ALBStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.LoadBalancer.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.CanaryTargetGroup.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.StableTargetGroup.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Ingress)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ALBTrafficRouting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ingress)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.ServicePort))
	l = len(m.RootService)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.AnnotationPrefix)
	n += 1 + l + sovGenerated(uint64(l))
	if m.StickinessConfig != nil {
		l = m.StickinessConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Ingresses) > 0 {
		for _, s := range m.Ingresses {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

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

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 *AnalysisRunArgument) 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))
	if m.ValueFrom != nil {
		l = m.ValueFrom.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 *AnalysisRunMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = 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 *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))
		}
	}
	if m.TTLStrategy != nil {
		l = m.TTLStrategy.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))
	}
	if m.CompletedAt != nil {
		l = m.CompletedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *AnalysisRunStrategy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SuccessfulRunHistoryLimit != nil {
		n += 1 + sovGenerated(uint64(*m.SuccessfulRunHistoryLimit))
	}
	if m.UnsuccessfulRunHistoryLimit != nil {
		n += 1 + sovGenerated(uint64(*m.UnsuccessfulRunHistoryLimit))
	}
	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 *AnalysisTemplateRef) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TemplateName)
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	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))
		}
	}
	if len(m.Templates) > 0 {
		for _, e := range m.Templates {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

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

func (m *ApisixRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Rules) > 0 {
		for _, s := range m.Rules {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

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

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

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

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

func (m *AppMeshVirtualService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Routes) > 0 {
		for _, s := range m.Routes {
			l = len(s)
			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 *ArgumentValueFrom) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PodTemplateHashValue != nil {
		l = len(*m.PodTemplateHashValue)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.FieldRef != nil {
		l = m.FieldRef.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 *AwsResourceRef) 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.ARN)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.FullName)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *BlueGreenStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PreviewSelector)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.ActiveSelector)
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	if m.PrePromotionAnalysisRunStatus != nil {
		l = m.PrePromotionAnalysisRunStatus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.PostPromotionAnalysisRunStatus != nil {
		l = m.PostPromotionAnalysisRunStatus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *BlueGreenStrategy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ActiveService)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.PreviewService)
	n += 1 + l + sovGenerated(uint64(l))
	if m.PreviewReplicaCount != nil {
		n += 1 + sovGenerated(uint64(*m.PreviewReplicaCount))
	}
	if m.AutoPromotionEnabled != nil {
		n += 2
	}
	n += 1 + sovGenerated(uint64(m.AutoPromotionSeconds))
	if m.MaxUnavailable != nil {
		l = m.MaxUnavailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ScaleDownDelaySeconds != nil {
		n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds))
	}
	if m.ScaleDownDelayRevisionLimit != nil {
		n += 1 + sovGenerated(uint64(*m.ScaleDownDelayRevisionLimit))
	}
	if m.PrePromotionAnalysis != nil {
		l = m.PrePromotionAnalysis.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.AntiAffinity != nil {
		l = m.AntiAffinity.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.PostPromotionAnalysis != nil {
		l = m.PostPromotionAnalysis.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.PreviewMetadata != nil {
		l = m.PreviewMetadata.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ActiveMetadata != nil {
		l = m.ActiveMetadata.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.AbortScaleDownDelaySeconds != nil {
		n += 1 + sovGenerated(uint64(*m.AbortScaleDownDelaySeconds))
	}
	return n
}

func (m *CanaryStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CurrentStepAnalysisRunStatus != nil {
		l = m.CurrentStepAnalysisRunStatus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.CurrentBackgroundAnalysisRunStatus != nil {
		l = m.CurrentBackgroundAnalysisRunStatus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.CurrentExperiment)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Weights != nil {
		l = m.Weights.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.StablePingPong)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.StepPluginStatuses) > 0 {
		for _, e := range m.StepPluginStatuses {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *CanaryStep) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SetWeight != nil {
		n += 1 + sovGenerated(uint64(*m.SetWeight))
	}
	if m.Pause != nil {
		l = m.Pause.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Experiment != nil {
		l = m.Experiment.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Analysis != nil {
		l = m.Analysis.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SetCanaryScale != nil {
		l = m.SetCanaryScale.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SetHeaderRoute != nil {
		l = m.SetHeaderRoute.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SetMirrorRoute != nil {
		l = m.SetMirrorRoute.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Plugin != nil {
		l = m.Plugin.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *CanaryStrategy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CanaryService)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.StableService)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Steps) > 0 {
		for _, e := range m.Steps {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.TrafficRouting != nil {
		l = m.TrafficRouting.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MaxUnavailable != nil {
		l = m.MaxUnavailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MaxSurge != nil {
		l = m.MaxSurge.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Analysis != nil {
		l = m.Analysis.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.AntiAffinity != nil {
		l = m.AntiAffinity.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.CanaryMetadata != nil {
		l = m.CanaryMetadata.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.StableMetadata != nil {
		l = m.StableMetadata.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ScaleDownDelaySeconds != nil {
		n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds))
	}
	if m.ScaleDownDelayRevisionLimit != nil {
		n += 1 + sovGenerated(uint64(*m.ScaleDownDelayRevisionLimit))
	}
	if m.AbortScaleDownDelaySeconds != nil {
		n += 1 + sovGenerated(uint64(*m.AbortScaleDownDelaySeconds))
	}
	n += 2
	if m.PingPong != nil {
		l = m.PingPong.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MinPodsPerReplicaSet != nil {
		n += 2 + sovGenerated(uint64(*m.MinPodsPerReplicaSet))
	}
	if m.ReplicaProgressThreshold != nil {
		l = m.ReplicaProgressThreshold.Size()
		n += 2 + 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 *ClusterAnalysisTemplate) 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 *ClusterAnalysisTemplateList) 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 *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))
	l = len(m.Aggregator)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.SecretRef.Size()
	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 *Experiment) 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 *ExperimentAnalysisRunStatus) 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.AnalysisRun)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Phase)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ExperimentAnalysisTemplateRef) 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.TemplateName)
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	n += 2
	return n
}

func (m *ExperimentCondition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Status)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastUpdateTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastTransitionTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Reason)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ExperimentList) 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 *ExperimentSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Templates) > 0 {
		for _, e := range m.Templates {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = len(m.Duration)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProgressDeadlineSeconds != nil {
		n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
	}
	n += 2
	if len(m.Analyses) > 0 {
		for _, e := range m.Analyses {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.ScaleDownDelaySeconds != nil {
		n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds))
	}
	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))
		}
	}
	l = m.AnalysisRunMetadata.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ExperimentStatus) 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.TemplateStatuses) > 0 {
		for _, e := range m.TemplateStatuses {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.AvailableAt != nil {
		l = m.AvailableAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.AnalysisRuns) > 0 {
		for _, e := range m.AnalysisRuns {
			l = e.Size()
			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 *HeaderRoutingMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.HeaderName)
	n += 1 + l + sovGenerated(uint64(l))
	if m.HeaderValue != nil {
		l = m.HeaderValue.Size()
		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 *IstioDestinationRule) 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.CanarySubsetName)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.StableSubsetName)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.AdditionalSubsetNames) > 0 {
		for _, s := range m.AdditionalSubsetNames {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *IstioTrafficRouting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VirtualService != nil {
		l = m.VirtualService.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.DestinationRule != nil {
		l = m.DestinationRule.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.VirtualServices) > 0 {
		for _, e := range m.VirtualServices {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *IstioVirtualService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Routes) > 0 {
		for _, s := range m.Routes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.TLSRoutes) > 0 {
		for _, e := range m.TLSRoutes {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.TCPRoutes) > 0 {
		for _, e := range m.TCPRoutes {
			l = e.Size()
			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))
		}
	}
	n += 2
	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 *MangedRoutes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	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))
	if m.ConsecutiveSuccessLimit != nil {
		l = m.ConsecutiveSuccessLimit.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))
		}
	}
	n += 1 + sovGenerated(uint64(m.ConsecutiveSuccess))
	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))
	if m.Timeout != nil {
		n += 1 + sovGenerated(uint64(*m.Timeout))
	}
	return n
}

func (m *NginxTrafficRouting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AnnotationPrefix)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.StableIngress)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.AdditionalIngressAnnotations) > 0 {
		for k, v := range m.AdditionalIngressAnnotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if len(m.StableIngresses) > 0 {
		for _, s := range m.StableIngresses {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.CanaryIngressAnnotations) > 0 {
		for k, v := range m.CanaryIngressAnnotations {
			_ = 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 *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 *ObjectRef) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.APIVersion)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Kind)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.ScaleDown)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

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

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

func (m *PodTemplateMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = 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 *PreferredDuringSchedulingIgnoredDuringExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.Weight))
	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))
		}
	}
	if m.RangeQuery != nil {
		l = m.RangeQuery.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

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

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

func (m *RequiredDuringSchedulingIgnoredDuringExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *Rollout) 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 *RolloutAnalysis) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Templates) > 0 {
		for _, e := range m.Templates {
			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))
		}
	}
	l = m.AnalysisRunMetadata.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *RolloutAnalysisRunStatus) 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.Status)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *RolloutCondition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Status)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastUpdateTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastTransitionTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Reason)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *RolloutExperimentStep) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Templates) > 0 {
		for _, e := range m.Templates {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = len(m.Duration)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Analyses) > 0 {
		for _, e := range m.Analyses {
			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))
		}
	}
	l = m.AnalysisRunMetadata.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.ScaleDownDelaySeconds != nil {
		n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds))
	}
	return n
}

func (m *RolloutExperimentStepAnalysisTemplateRef) 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.TemplateName)
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	n += 2
	return n
}

func (m *RolloutExperimentTemplate) 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.SpecRef)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Replicas != nil {
		n += 1 + sovGenerated(uint64(*m.Replicas))
	}
	l = m.Metadata.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Selector != nil {
		l = m.Selector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Weight != nil {
		n += 1 + sovGenerated(uint64(*m.Weight))
	}
	if m.Service != nil {
		l = m.Service.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *RolloutList) 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 *RolloutPause) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *RolloutSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Replicas != nil {
		n += 1 + sovGenerated(uint64(*m.Replicas))
	}
	if m.Selector != nil {
		l = m.Selector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Template.Size()
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
	l = m.Strategy.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.RevisionHistoryLimit != nil {
		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
	}
	n += 2
	if m.ProgressDeadlineSeconds != nil {
		n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
	}
	if m.RestartAt != nil {
		l = m.RestartAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.WorkloadRef != nil {
		l = m.WorkloadRef.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Analysis != nil {
		l = m.Analysis.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	n += 2
	if m.RollbackWindow != nil {
		l = m.RollbackWindow.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *RolloutStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	if len(m.PauseConditions) > 0 {
		for _, e := range m.PauseConditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	n += 2
	if m.AbortedAt != nil {
		l = m.AbortedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.CurrentPodHash)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.CurrentStepHash)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Replicas))
	n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
	if m.CurrentStepIndex != nil {
		n += 1 + sovGenerated(uint64(*m.CurrentStepIndex))
	}
	if m.CollisionCount != nil {
		n += 1 + sovGenerated(uint64(*m.CollisionCount))
	}
	l = len(m.ObservedGeneration)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = m.Canary.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.BlueGreen.Size()
	n += 2 + l + sovGenerated(uint64(l))
	n += 2 + sovGenerated(uint64(m.HPAReplicas))
	l = len(m.Selector)
	n += 2 + l + sovGenerated(uint64(l))
	l = len(m.StableRS)
	n += 2 + l + sovGenerated(uint64(l))
	if m.RestartedAt != nil {
		l = m.RestartedAt.Size()
		n += 2 + l + sovGenerated(uint64(l))
	}
	n += 3
	l = len(m.Phase)
	n += 2 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 2 + l + sovGenerated(uint64(l))
	l = len(m.WorkloadObservedGeneration)
	n += 2 + l + sovGenerated(uint64(l))
	if m.ALB != nil {
		l = m.ALB.Size()
		n += 2 + l + sovGenerated(uint64(l))
	}
	if len(m.ALBs) > 0 {
		for _, e := range m.ALBs {
			l = e.Size()
			n += 2 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

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

func (m *RolloutTrafficRouting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Istio != nil {
		l = m.Istio.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Nginx != nil {
		l = m.Nginx.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ALB != nil {
		l = m.ALB.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SMI != nil {
		l = m.SMI.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Ambassador != nil {
		l = m.Ambassador.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.AppMesh != nil {
		l = m.AppMesh.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Traefik != nil {
		l = m.Traefik.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.ManagedRoutes) > 0 {
		for _, e := range m.ManagedRoutes {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Apisix != nil {
		l = m.Apisix.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Plugins) > 0 {
		for k, v := range m.Plugins {
			_ = 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))
		}
	}
	if m.MaxTrafficWeight != nil {
		n += 1 + sovGenerated(uint64(*m.MaxTrafficWeight))
	}
	return n
}

func (m *RouteMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Method != nil {
		l = m.Method.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Path != nil {
		l = m.Path.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Headers) > 0 {
		for k, v := range m.Headers {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	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 *SMITrafficRouting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RootService)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.TrafficSplitName)
	n += 1 + l + sovGenerated(uint64(l))
	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 *SecretRef) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	return n
}

func (m *SetCanaryScale) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Weight != nil {
		n += 1 + sovGenerated(uint64(*m.Weight))
	}
	if m.Replicas != nil {
		n += 1 + sovGenerated(uint64(*m.Replicas))
	}
	n += 2
	return n
}

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

func (m *SetMirrorRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Match) > 0 {
		for _, e := range m.Match {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Percentage != nil {
		n += 1 + sovGenerated(uint64(*m.Percentage))
	}
	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 *StepPluginStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.Index))
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Operation)
	n += 1 + l + sovGenerated(uint64(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.UpdatedAt != nil {
		l = m.UpdatedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.FinishedAt != nil {
		l = m.FinishedAt.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Backoff)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Executions))
	n += 2
	if m.Status != nil {
		l = len(m.Status)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *StickinessConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	n += 1 + sovGenerated(uint64(m.DurationSeconds))
	return n
}

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

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

func (m *TLSRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.Port))
	if len(m.SNIHosts) > 0 {
		for _, s := range m.SNIHosts {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *TTLStrategy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SecondsAfterCompletion != nil {
		n += 1 + sovGenerated(uint64(*m.SecondsAfterCompletion))
	}
	if m.SecondsAfterFailure != nil {
		n += 1 + sovGenerated(uint64(*m.SecondsAfterFailure))
	}
	if m.SecondsAfterSuccess != nil {
		n += 1 + sovGenerated(uint64(*m.SecondsAfterSuccess))
	}
	return n
}

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

func (m *TemplateSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Replicas != nil {
		n += 1 + sovGenerated(uint64(*m.Replicas))
	}
	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
	if m.Selector != nil {
		l = m.Selector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Template.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Service != nil {
		l = m.Service.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *TemplateStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Replicas))
	n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
	if m.CollisionCount != nil {
		n += 1 + sovGenerated(uint64(*m.CollisionCount))
	}
	l = len(m.Status)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	if m.LastTransitionTime != nil {
		l = m.LastTransitionTime.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.ServiceName)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.PodTemplateHash)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *TrafficWeights) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Canary.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Stable.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Additional) > 0 {
		for _, e := range m.Additional {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Verified != nil {
		n += 2
	}
	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 (m *WeightDestination) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.Weight))
	l = len(m.ServiceName)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.PodTemplateHash)
	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 *ALBStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ALBStatus{`,
		`LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "AwsResourceRef", "AwsResourceRef", 1), `&`, ``, 1) + `,`,
		`CanaryTargetGroup:` + strings.Replace(strings.Replace(this.CanaryTargetGroup.String(), "AwsResourceRef", "AwsResourceRef", 1), `&`, ``, 1) + `,`,
		`StableTargetGroup:` + strings.Replace(strings.Replace(this.StableTargetGroup.String(), "AwsResourceRef", "AwsResourceRef", 1), `&`, ``, 1) + `,`,
		`Ingress:` + fmt.Sprintf("%v", this.Ingress) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ALBTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ALBTrafficRouting{`,
		`Ingress:` + fmt.Sprintf("%v", this.Ingress) + `,`,
		`ServicePort:` + fmt.Sprintf("%v", this.ServicePort) + `,`,
		`RootService:` + fmt.Sprintf("%v", this.RootService) + `,`,
		`AnnotationPrefix:` + fmt.Sprintf("%v", this.AnnotationPrefix) + `,`,
		`StickinessConfig:` + strings.Replace(this.StickinessConfig.String(), "StickinessConfig", "StickinessConfig", 1) + `,`,
		`Ingresses:` + fmt.Sprintf("%v", this.Ingresses) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AmbassadorTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AmbassadorTrafficRouting{`,
		`Mappings:` + fmt.Sprintf("%v", this.Mappings) + `,`,
		`}`,
	}, "")
	return s
}
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 *AnalysisRunArgument) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AnalysisRunArgument{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`ValueFrom:` + strings.Replace(this.ValueFrom.String(), "ArgumentValueFrom", "ArgumentValueFrom", 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 *AnalysisRunMetadata) String() string {
	if this == nil {
		return "nil"
	}
	keysForLabels := make([]string, 0, len(this.Labels))
	for k := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	s := strings.Join([]string{`&AnalysisRunMetadata{`,
		`Labels:` + mapStringForLabels + `,`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`}`,
	}, "")
	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 + `,`,
		`TTLStrategy:` + strings.Replace(this.TTLStrategy.String(), "TTLStrategy", "TTLStrategy", 1) + `,`,
		`}`,
	}, "")
	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) + `,`,
		`CompletedAt:` + strings.Replace(fmt.Sprintf("%v", this.CompletedAt), "Time", "v1.Time", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnalysisRunStrategy) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AnalysisRunStrategy{`,
		`SuccessfulRunHistoryLimit:` + valueToStringGenerated(this.SuccessfulRunHistoryLimit) + `,`,
		`UnsuccessfulRunHistoryLimit:` + valueToStringGenerated(this.UnsuccessfulRunHistoryLimit) + `,`,
		`}`,
	}, "")
	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 *AnalysisTemplateRef) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AnalysisTemplateRef{`,
		`TemplateName:` + fmt.Sprintf("%v", this.TemplateName) + `,`,
		`ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`,
		`}`,
	}, "")
	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 += "}"
	repeatedStringForTemplates := "[]AnalysisTemplateRef{"
	for _, f := range this.Templates {
		repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "AnalysisTemplateRef", "AnalysisTemplateRef", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTemplates += "}"
	s := strings.Join([]string{`&AnalysisTemplateSpec{`,
		`Metrics:` + repeatedStringForMetrics + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`DryRun:` + repeatedStringForDryRun + `,`,
		`MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`,
		`Templates:` + repeatedStringForTemplates + `,`,
		`}`,
	}, "")
	return s
}
func (this *AntiAffinity) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AntiAffinity{`,
		`PreferredDuringSchedulingIgnoredDuringExecution:` + strings.Replace(this.PreferredDuringSchedulingIgnoredDuringExecution.String(), "PreferredDuringSchedulingIgnoredDuringExecution", "PreferredDuringSchedulingIgnoredDuringExecution", 1) + `,`,
		`RequiredDuringSchedulingIgnoredDuringExecution:` + strings.Replace(this.RequiredDuringSchedulingIgnoredDuringExecution.String(), "RequiredDuringSchedulingIgnoredDuringExecution", "RequiredDuringSchedulingIgnoredDuringExecution", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApisixRoute) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApisixRoute{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Rules:` + fmt.Sprintf("%v", this.Rules) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApisixTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApisixTrafficRouting{`,
		`Route:` + strings.Replace(this.Route.String(), "ApisixRoute", "ApisixRoute", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AppMeshTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AppMeshTrafficRouting{`,
		`VirtualService:` + strings.Replace(this.VirtualService.String(), "AppMeshVirtualService", "AppMeshVirtualService", 1) + `,`,
		`VirtualNodeGroup:` + strings.Replace(this.VirtualNodeGroup.String(), "AppMeshVirtualNodeGroup", "AppMeshVirtualNodeGroup", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AppMeshVirtualNodeGroup) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AppMeshVirtualNodeGroup{`,
		`CanaryVirtualNodeRef:` + strings.Replace(this.CanaryVirtualNodeRef.String(), "AppMeshVirtualNodeReference", "AppMeshVirtualNodeReference", 1) + `,`,
		`StableVirtualNodeRef:` + strings.Replace(this.StableVirtualNodeRef.String(), "AppMeshVirtualNodeReference", "AppMeshVirtualNodeReference", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AppMeshVirtualNodeReference) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AppMeshVirtualNodeReference{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AppMeshVirtualService) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AppMeshVirtualService{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Routes:` + fmt.Sprintf("%v", this.Routes) + `,`,
		`}`,
	}, "")
	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 *ArgumentValueFrom) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ArgumentValueFrom{`,
		`PodTemplateHashValue:` + valueToStringGenerated(this.PodTemplateHashValue) + `,`,
		`FieldRef:` + strings.Replace(this.FieldRef.String(), "FieldRef", "FieldRef", 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 *AwsResourceRef) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AwsResourceRef{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ARN:` + fmt.Sprintf("%v", this.ARN) + `,`,
		`FullName:` + fmt.Sprintf("%v", this.FullName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BlueGreenStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BlueGreenStatus{`,
		`PreviewSelector:` + fmt.Sprintf("%v", this.PreviewSelector) + `,`,
		`ActiveSelector:` + fmt.Sprintf("%v", this.ActiveSelector) + `,`,
		`ScaleUpPreviewCheckPoint:` + fmt.Sprintf("%v", this.ScaleUpPreviewCheckPoint) + `,`,
		`PrePromotionAnalysisRunStatus:` + strings.Replace(this.PrePromotionAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`,
		`PostPromotionAnalysisRunStatus:` + strings.Replace(this.PostPromotionAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BlueGreenStrategy) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BlueGreenStrategy{`,
		`ActiveService:` + fmt.Sprintf("%v", this.ActiveService) + `,`,
		`PreviewService:` + fmt.Sprintf("%v", this.PreviewService) + `,`,
		`PreviewReplicaCount:` + valueToStringGenerated(this.PreviewReplicaCount) + `,`,
		`AutoPromotionEnabled:` + valueToStringGenerated(this.AutoPromotionEnabled) + `,`,
		`AutoPromotionSeconds:` + fmt.Sprintf("%v", this.AutoPromotionSeconds) + `,`,
		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`,
		`ScaleDownDelayRevisionLimit:` + valueToStringGenerated(this.ScaleDownDelayRevisionLimit) + `,`,
		`PrePromotionAnalysis:` + strings.Replace(this.PrePromotionAnalysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1) + `,`,
		`AntiAffinity:` + strings.Replace(this.AntiAffinity.String(), "AntiAffinity", "AntiAffinity", 1) + `,`,
		`PostPromotionAnalysis:` + strings.Replace(this.PostPromotionAnalysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1) + `,`,
		`PreviewMetadata:` + strings.Replace(this.PreviewMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`,
		`ActiveMetadata:` + strings.Replace(this.ActiveMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`,
		`AbortScaleDownDelaySeconds:` + valueToStringGenerated(this.AbortScaleDownDelaySeconds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CanaryStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForStepPluginStatuses := "[]StepPluginStatus{"
	for _, f := range this.StepPluginStatuses {
		repeatedStringForStepPluginStatuses += strings.Replace(strings.Replace(f.String(), "StepPluginStatus", "StepPluginStatus", 1), `&`, ``, 1) + ","
	}
	repeatedStringForStepPluginStatuses += "}"
	s := strings.Join([]string{`&CanaryStatus{`,
		`CurrentStepAnalysisRunStatus:` + strings.Replace(this.CurrentStepAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`,
		`CurrentBackgroundAnalysisRunStatus:` + strings.Replace(this.CurrentBackgroundAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`,
		`CurrentExperiment:` + fmt.Sprintf("%v", this.CurrentExperiment) + `,`,
		`Weights:` + strings.Replace(this.Weights.String(), "TrafficWeights", "TrafficWeights", 1) + `,`,
		`StablePingPong:` + fmt.Sprintf("%v", this.StablePingPong) + `,`,
		`StepPluginStatuses:` + repeatedStringForStepPluginStatuses + `,`,
		`}`,
	}, "")
	return s
}
func (this *CanaryStep) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CanaryStep{`,
		`SetWeight:` + valueToStringGenerated(this.SetWeight) + `,`,
		`Pause:` + strings.Replace(this.Pause.String(), "RolloutPause", "RolloutPause", 1) + `,`,
		`Experiment:` + strings.Replace(this.Experiment.String(), "RolloutExperimentStep", "RolloutExperimentStep", 1) + `,`,
		`Analysis:` + strings.Replace(this.Analysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1) + `,`,
		`SetCanaryScale:` + strings.Replace(this.SetCanaryScale.String(), "SetCanaryScale", "SetCanaryScale", 1) + `,`,
		`SetHeaderRoute:` + strings.Replace(this.SetHeaderRoute.String(), "SetHeaderRoute", "SetHeaderRoute", 1) + `,`,
		`SetMirrorRoute:` + strings.Replace(this.SetMirrorRoute.String(), "SetMirrorRoute", "SetMirrorRoute", 1) + `,`,
		`Plugin:` + strings.Replace(this.Plugin.String(), "PluginStep", "PluginStep", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CanaryStrategy) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSteps := "[]CanaryStep{"
	for _, f := range this.Steps {
		repeatedStringForSteps += strings.Replace(strings.Replace(f.String(), "CanaryStep", "CanaryStep", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSteps += "}"
	s := strings.Join([]string{`&CanaryStrategy{`,
		`CanaryService:` + fmt.Sprintf("%v", this.CanaryService) + `,`,
		`StableService:` + fmt.Sprintf("%v", this.StableService) + `,`,
		`Steps:` + repeatedStringForSteps + `,`,
		`TrafficRouting:` + strings.Replace(this.TrafficRouting.String(), "RolloutTrafficRouting", "RolloutTrafficRouting", 1) + `,`,
		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`Analysis:` + strings.Replace(this.Analysis.String(), "RolloutAnalysisBackground", "RolloutAnalysisBackground", 1) + `,`,
		`AntiAffinity:` + strings.Replace(this.AntiAffinity.String(), "AntiAffinity", "AntiAffinity", 1) + `,`,
		`CanaryMetadata:` + strings.Replace(this.CanaryMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`,
		`StableMetadata:` + strings.Replace(this.StableMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`,
		`ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`,
		`ScaleDownDelayRevisionLimit:` + valueToStringGenerated(this.ScaleDownDelayRevisionLimit) + `,`,
		`AbortScaleDownDelaySeconds:` + valueToStringGenerated(this.AbortScaleDownDelaySeconds) + `,`,
		`DynamicStableScale:` + fmt.Sprintf("%v", this.DynamicStableScale) + `,`,
		`PingPong:` + strings.Replace(this.PingPong.String(), "PingPongSpec", "PingPongSpec", 1) + `,`,
		`MinPodsPerReplicaSet:` + valueToStringGenerated(this.MinPodsPerReplicaSet) + `,`,
		`ReplicaProgressThreshold:` + strings.Replace(this.ReplicaProgressThreshold.String(), "ReplicaProgressThreshold", "ReplicaProgressThreshold", 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 *ClusterAnalysisTemplate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ClusterAnalysisTemplate{`,
		`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 *ClusterAnalysisTemplateList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]ClusterAnalysisTemplate{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ClusterAnalysisTemplate", "ClusterAnalysisTemplate", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ClusterAnalysisTemplateList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	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) + `,`,
		`Aggregator:` + fmt.Sprintf("%v", this.Aggregator) + `,`,
		`SecretRef:` + strings.Replace(strings.Replace(this.SecretRef.String(), "SecretRef", "SecretRef", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	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 *Experiment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Experiment{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ExperimentSpec", "ExperimentSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ExperimentStatus", "ExperimentStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExperimentAnalysisRunStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExperimentAnalysisRunStatus{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`AnalysisRun:` + fmt.Sprintf("%v", this.AnalysisRun) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExperimentAnalysisTemplateRef) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgs := "[]Argument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "Argument", "Argument", 1), `&`, ``, 1) + ","
	}
	repeatedStringForArgs += "}"
	s := strings.Join([]string{`&ExperimentAnalysisTemplateRef{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`TemplateName:` + fmt.Sprintf("%v", this.TemplateName) + `,`,
		`ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`RequiredForCompletion:` + fmt.Sprintf("%v", this.RequiredForCompletion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExperimentCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExperimentCondition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExperimentList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Experiment{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Experiment", "Experiment", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ExperimentList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExperimentSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTemplates := "[]TemplateSpec{"
	for _, f := range this.Templates {
		repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "TemplateSpec", "TemplateSpec", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTemplates += "}"
	repeatedStringForAnalyses := "[]ExperimentAnalysisTemplateRef{"
	for _, f := range this.Analyses {
		repeatedStringForAnalyses += strings.Replace(strings.Replace(f.String(), "ExperimentAnalysisTemplateRef", "ExperimentAnalysisTemplateRef", 1), `&`, ``, 1) + ","
	}
	repeatedStringForAnalyses += "}"
	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{`&ExperimentSpec{`,
		`Templates:` + repeatedStringForTemplates + `,`,
		`Duration:` + fmt.Sprintf("%v", this.Duration) + `,`,
		`ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
		`Terminate:` + fmt.Sprintf("%v", this.Terminate) + `,`,
		`Analyses:` + repeatedStringForAnalyses + `,`,
		`ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`,
		`DryRun:` + repeatedStringForDryRun + `,`,
		`MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`,
		`AnalysisRunMetadata:` + strings.Replace(strings.Replace(this.AnalysisRunMetadata.String(), "AnalysisRunMetadata", "AnalysisRunMetadata", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExperimentStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTemplateStatuses := "[]TemplateStatus{"
	for _, f := range this.TemplateStatuses {
		repeatedStringForTemplateStatuses += strings.Replace(strings.Replace(f.String(), "TemplateStatus", "TemplateStatus", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTemplateStatuses += "}"
	repeatedStringForConditions := "[]ExperimentCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ExperimentCondition", "ExperimentCondition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConditions += "}"
	repeatedStringForAnalysisRuns := "[]ExperimentAnalysisRunStatus{"
	for _, f := range this.AnalysisRuns {
		repeatedStringForAnalysisRuns += strings.Replace(strings.Replace(f.String(), "ExperimentAnalysisRunStatus", "ExperimentAnalysisRunStatus", 1), `&`, ``, 1) + ","
	}
	repeatedStringForAnalysisRuns += "}"
	s := strings.Join([]string{`&ExperimentStatus{`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`TemplateStatuses:` + repeatedStringForTemplateStatuses + `,`,
		`AvailableAt:` + strings.Replace(fmt.Sprintf("%v", this.AvailableAt), "Time", "v1.Time", 1) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`AnalysisRuns:` + repeatedStringForAnalysisRuns + `,`,
		`}`,
	}, "")
	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 *HeaderRoutingMatch) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HeaderRoutingMatch{`,
		`HeaderName:` + fmt.Sprintf("%v", this.HeaderName) + `,`,
		`HeaderValue:` + strings.Replace(this.HeaderValue.String(), "StringMatch", "StringMatch", 1) + `,`,
		`}`,
	}, "")
	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 *IstioDestinationRule) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IstioDestinationRule{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`CanarySubsetName:` + fmt.Sprintf("%v", this.CanarySubsetName) + `,`,
		`StableSubsetName:` + fmt.Sprintf("%v", this.StableSubsetName) + `,`,
		`AdditionalSubsetNames:` + fmt.Sprintf("%v", this.AdditionalSubsetNames) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IstioTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForVirtualServices := "[]IstioVirtualService{"
	for _, f := range this.VirtualServices {
		repeatedStringForVirtualServices += strings.Replace(strings.Replace(f.String(), "IstioVirtualService", "IstioVirtualService", 1), `&`, ``, 1) + ","
	}
	repeatedStringForVirtualServices += "}"
	s := strings.Join([]string{`&IstioTrafficRouting{`,
		`VirtualService:` + strings.Replace(this.VirtualService.String(), "IstioVirtualService", "IstioVirtualService", 1) + `,`,
		`DestinationRule:` + strings.Replace(this.DestinationRule.String(), "IstioDestinationRule", "IstioDestinationRule", 1) + `,`,
		`VirtualServices:` + repeatedStringForVirtualServices + `,`,
		`}`,
	}, "")
	return s
}
func (this *IstioVirtualService) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTLSRoutes := "[]TLSRoute{"
	for _, f := range this.TLSRoutes {
		repeatedStringForTLSRoutes += strings.Replace(strings.Replace(f.String(), "TLSRoute", "TLSRoute", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTLSRoutes += "}"
	repeatedStringForTCPRoutes := "[]TCPRoute{"
	for _, f := range this.TCPRoutes {
		repeatedStringForTCPRoutes += strings.Replace(strings.Replace(f.String(), "TCPRoute", "TCPRoute", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTCPRoutes += "}"
	s := strings.Join([]string{`&IstioVirtualService{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Routes:` + fmt.Sprintf("%v", this.Routes) + `,`,
		`TLSRoutes:` + repeatedStringForTLSRoutes + `,`,
		`TCPRoutes:` + repeatedStringForTCPRoutes + `,`,
		`}`,
	}, "")
	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 + `,`,
		`Lookback:` + fmt.Sprintf("%v", this.Lookback) + `,`,
		`}`,
	}, "")
	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 *MangedRoutes) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MangedRoutes{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	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) + `,`,
		`ConsecutiveSuccessLimit:` + strings.Replace(fmt.Sprintf("%v", this.ConsecutiveSuccessLimit), "IntOrString", "intstr.IntOrString", 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 + `,`,
		`ConsecutiveSuccess:` + fmt.Sprintf("%v", this.ConsecutiveSuccess) + `,`,
		`}`,
	}, "")
	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) + `,`,
		`Timeout:` + valueToStringGenerated(this.Timeout) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NginxTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	keysForAdditionalIngressAnnotations := make([]string, 0, len(this.AdditionalIngressAnnotations))
	for k := range this.AdditionalIngressAnnotations {
		keysForAdditionalIngressAnnotations = append(keysForAdditionalIngressAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAdditionalIngressAnnotations)
	mapStringForAdditionalIngressAnnotations := "map[string]string{"
	for _, k := range keysForAdditionalIngressAnnotations {
		mapStringForAdditionalIngressAnnotations += fmt.Sprintf("%v: %v,", k, this.AdditionalIngressAnnotations[k])
	}
	mapStringForAdditionalIngressAnnotations += "}"
	keysForCanaryIngressAnnotations := make([]string, 0, len(this.CanaryIngressAnnotations))
	for k := range this.CanaryIngressAnnotations {
		keysForCanaryIngressAnnotations = append(keysForCanaryIngressAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForCanaryIngressAnnotations)
	mapStringForCanaryIngressAnnotations := "map[string]string{"
	for _, k := range keysForCanaryIngressAnnotations {
		mapStringForCanaryIngressAnnotations += fmt.Sprintf("%v: %v,", k, this.CanaryIngressAnnotations[k])
	}
	mapStringForCanaryIngressAnnotations += "}"
	s := strings.Join([]string{`&NginxTrafficRouting{`,
		`AnnotationPrefix:` + fmt.Sprintf("%v", this.AnnotationPrefix) + `,`,
		`StableIngress:` + fmt.Sprintf("%v", this.StableIngress) + `,`,
		`AdditionalIngressAnnotations:` + mapStringForAdditionalIngressAnnotations + `,`,
		`StableIngresses:` + fmt.Sprintf("%v", this.StableIngresses) + `,`,
		`CanaryIngressAnnotations:` + mapStringForCanaryIngressAnnotations + `,`,
		`}`,
	}, "")
	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 *ObjectRef) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ObjectRef{`,
		`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ScaleDown:` + fmt.Sprintf("%v", this.ScaleDown) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PauseCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PauseCondition{`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`StartTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.StartTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PingPongSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PingPongSpec{`,
		`PingService:` + fmt.Sprintf("%v", this.PingService) + `,`,
		`PongService:` + fmt.Sprintf("%v", this.PongService) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PluginStep) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PluginStep{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Config:` + valueToStringGenerated(this.Config) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodTemplateMetadata) String() string {
	if this == nil {
		return "nil"
	}
	keysForLabels := make([]string, 0, len(this.Labels))
	for k := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	s := strings.Join([]string{`&PodTemplateMetadata{`,
		`Labels:` + mapStringForLabels + `,`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`}`,
	}, "")
	return s
}
func (this *PreferredDuringSchedulingIgnoredDuringExecution) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PreferredDuringSchedulingIgnoredDuringExecution{`,
		`Weight:` + fmt.Sprintf("%v", this.Weight) + `,`,
		`}`,
	}, "")
	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 + `,`,
		`RangeQuery:` + strings.Replace(this.RangeQuery.String(), "PrometheusRangeQueryArgs", "PrometheusRangeQueryArgs", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PrometheusRangeQueryArgs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PrometheusRangeQueryArgs{`,
		`Start:` + fmt.Sprintf("%v", this.Start) + `,`,
		`End:` + fmt.Sprintf("%v", this.End) + `,`,
		`Step:` + fmt.Sprintf("%v", this.Step) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReplicaProgressThreshold) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ReplicaProgressThreshold{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequiredDuringSchedulingIgnoredDuringExecution) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequiredDuringSchedulingIgnoredDuringExecution{`,
		`}`,
	}, "")
	return s
}
func (this *RollbackWindowSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RollbackWindowSpec{`,
		`Revisions:` + fmt.Sprintf("%v", this.Revisions) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Rollout) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Rollout{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "RolloutSpec", "RolloutSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "RolloutStatus", "RolloutStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutAnalysis) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTemplates := "[]AnalysisTemplateRef{"
	for _, f := range this.Templates {
		repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "AnalysisTemplateRef", "AnalysisTemplateRef", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTemplates += "}"
	repeatedStringForArgs := "[]AnalysisRunArgument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "AnalysisRunArgument", "AnalysisRunArgument", 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{`&RolloutAnalysis{`,
		`Templates:` + repeatedStringForTemplates + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`DryRun:` + repeatedStringForDryRun + `,`,
		`MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`,
		`AnalysisRunMetadata:` + strings.Replace(strings.Replace(this.AnalysisRunMetadata.String(), "AnalysisRunMetadata", "AnalysisRunMetadata", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutAnalysisBackground) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutAnalysisBackground{`,
		`RolloutAnalysis:` + strings.Replace(strings.Replace(this.RolloutAnalysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1), `&`, ``, 1) + `,`,
		`StartingStep:` + valueToStringGenerated(this.StartingStep) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutAnalysisRunStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutAnalysisRunStatus{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutCondition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutExperimentStep) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTemplates := "[]RolloutExperimentTemplate{"
	for _, f := range this.Templates {
		repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "RolloutExperimentTemplate", "RolloutExperimentTemplate", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTemplates += "}"
	repeatedStringForAnalyses := "[]RolloutExperimentStepAnalysisTemplateRef{"
	for _, f := range this.Analyses {
		repeatedStringForAnalyses += strings.Replace(strings.Replace(f.String(), "RolloutExperimentStepAnalysisTemplateRef", "RolloutExperimentStepAnalysisTemplateRef", 1), `&`, ``, 1) + ","
	}
	repeatedStringForAnalyses += "}"
	repeatedStringForDryRun := "[]DryRun{"
	for _, f := range this.DryRun {
		repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + ","
	}
	repeatedStringForDryRun += "}"
	s := strings.Join([]string{`&RolloutExperimentStep{`,
		`Templates:` + repeatedStringForTemplates + `,`,
		`Duration:` + fmt.Sprintf("%v", this.Duration) + `,`,
		`Analyses:` + repeatedStringForAnalyses + `,`,
		`DryRun:` + repeatedStringForDryRun + `,`,
		`AnalysisRunMetadata:` + strings.Replace(strings.Replace(this.AnalysisRunMetadata.String(), "AnalysisRunMetadata", "AnalysisRunMetadata", 1), `&`, ``, 1) + `,`,
		`ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutExperimentStepAnalysisTemplateRef) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgs := "[]AnalysisRunArgument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "AnalysisRunArgument", "AnalysisRunArgument", 1), `&`, ``, 1) + ","
	}
	repeatedStringForArgs += "}"
	s := strings.Join([]string{`&RolloutExperimentStepAnalysisTemplateRef{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`TemplateName:` + fmt.Sprintf("%v", this.TemplateName) + `,`,
		`ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`RequiredForCompletion:` + fmt.Sprintf("%v", this.RequiredForCompletion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutExperimentTemplate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutExperimentTemplate{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`SpecRef:` + fmt.Sprintf("%v", this.SpecRef) + `,`,
		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
		`Metadata:` + strings.Replace(strings.Replace(this.Metadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1), `&`, ``, 1) + `,`,
		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
		`Weight:` + valueToStringGenerated(this.Weight) + `,`,
		`Service:` + strings.Replace(this.Service.String(), "TemplateService", "TemplateService", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Rollout{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Rollout", "Rollout", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&RolloutList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutPause) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutPause{`,
		`Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutSpec{`,
		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
		`Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v12.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
		`Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "RolloutStrategy", "RolloutStrategy", 1), `&`, ``, 1) + `,`,
		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
		`Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
		`ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
		`RestartAt:` + strings.Replace(fmt.Sprintf("%v", this.RestartAt), "Time", "v1.Time", 1) + `,`,
		`WorkloadRef:` + strings.Replace(this.WorkloadRef.String(), "ObjectRef", "ObjectRef", 1) + `,`,
		`Analysis:` + strings.Replace(this.Analysis.String(), "AnalysisRunStrategy", "AnalysisRunStrategy", 1) + `,`,
		`ProgressDeadlineAbort:` + fmt.Sprintf("%v", this.ProgressDeadlineAbort) + `,`,
		`RollbackWindow:` + strings.Replace(this.RollbackWindow.String(), "RollbackWindowSpec", "RollbackWindowSpec", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPauseConditions := "[]PauseCondition{"
	for _, f := range this.PauseConditions {
		repeatedStringForPauseConditions += strings.Replace(strings.Replace(f.String(), "PauseCondition", "PauseCondition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForPauseConditions += "}"
	repeatedStringForConditions := "[]RolloutCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "RolloutCondition", "RolloutCondition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConditions += "}"
	repeatedStringForALBs := "[]ALBStatus{"
	for _, f := range this.ALBs {
		repeatedStringForALBs += strings.Replace(strings.Replace(f.String(), "ALBStatus", "ALBStatus", 1), `&`, ``, 1) + ","
	}
	repeatedStringForALBs += "}"
	s := strings.Join([]string{`&RolloutStatus{`,
		`Abort:` + fmt.Sprintf("%v", this.Abort) + `,`,
		`PauseConditions:` + repeatedStringForPauseConditions + `,`,
		`ControllerPause:` + fmt.Sprintf("%v", this.ControllerPause) + `,`,
		`AbortedAt:` + strings.Replace(fmt.Sprintf("%v", this.AbortedAt), "Time", "v1.Time", 1) + `,`,
		`CurrentPodHash:` + fmt.Sprintf("%v", this.CurrentPodHash) + `,`,
		`CurrentStepHash:` + fmt.Sprintf("%v", this.CurrentStepHash) + `,`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
		`CurrentStepIndex:` + valueToStringGenerated(this.CurrentStepIndex) + `,`,
		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`Canary:` + strings.Replace(strings.Replace(this.Canary.String(), "CanaryStatus", "CanaryStatus", 1), `&`, ``, 1) + `,`,
		`BlueGreen:` + strings.Replace(strings.Replace(this.BlueGreen.String(), "BlueGreenStatus", "BlueGreenStatus", 1), `&`, ``, 1) + `,`,
		`HPAReplicas:` + fmt.Sprintf("%v", this.HPAReplicas) + `,`,
		`Selector:` + fmt.Sprintf("%v", this.Selector) + `,`,
		`StableRS:` + fmt.Sprintf("%v", this.StableRS) + `,`,
		`RestartedAt:` + strings.Replace(fmt.Sprintf("%v", this.RestartedAt), "Time", "v1.Time", 1) + `,`,
		`PromoteFull:` + fmt.Sprintf("%v", this.PromoteFull) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`WorkloadObservedGeneration:` + fmt.Sprintf("%v", this.WorkloadObservedGeneration) + `,`,
		`ALB:` + strings.Replace(this.ALB.String(), "ALBStatus", "ALBStatus", 1) + `,`,
		`ALBs:` + repeatedStringForALBs + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutStrategy) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RolloutStrategy{`,
		`BlueGreen:` + strings.Replace(this.BlueGreen.String(), "BlueGreenStrategy", "BlueGreenStrategy", 1) + `,`,
		`Canary:` + strings.Replace(this.Canary.String(), "CanaryStrategy", "CanaryStrategy", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RolloutTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForManagedRoutes := "[]MangedRoutes{"
	for _, f := range this.ManagedRoutes {
		repeatedStringForManagedRoutes += strings.Replace(strings.Replace(f.String(), "MangedRoutes", "MangedRoutes", 1), `&`, ``, 1) + ","
	}
	repeatedStringForManagedRoutes += "}"
	keysForPlugins := make([]string, 0, len(this.Plugins))
	for k := range this.Plugins {
		keysForPlugins = append(keysForPlugins, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForPlugins)
	mapStringForPlugins := "map[string]encoding_json.RawMessage{"
	for _, k := range keysForPlugins {
		mapStringForPlugins += fmt.Sprintf("%v: %v,", k, this.Plugins[k])
	}
	mapStringForPlugins += "}"
	s := strings.Join([]string{`&RolloutTrafficRouting{`,
		`Istio:` + strings.Replace(this.Istio.String(), "IstioTrafficRouting", "IstioTrafficRouting", 1) + `,`,
		`Nginx:` + strings.Replace(this.Nginx.String(), "NginxTrafficRouting", "NginxTrafficRouting", 1) + `,`,
		`ALB:` + strings.Replace(this.ALB.String(), "ALBTrafficRouting", "ALBTrafficRouting", 1) + `,`,
		`SMI:` + strings.Replace(this.SMI.String(), "SMITrafficRouting", "SMITrafficRouting", 1) + `,`,
		`Ambassador:` + strings.Replace(this.Ambassador.String(), "AmbassadorTrafficRouting", "AmbassadorTrafficRouting", 1) + `,`,
		`AppMesh:` + strings.Replace(this.AppMesh.String(), "AppMeshTrafficRouting", "AppMeshTrafficRouting", 1) + `,`,
		`Traefik:` + strings.Replace(this.Traefik.String(), "TraefikTrafficRouting", "TraefikTrafficRouting", 1) + `,`,
		`ManagedRoutes:` + repeatedStringForManagedRoutes + `,`,
		`Apisix:` + strings.Replace(this.Apisix.String(), "ApisixTrafficRouting", "ApisixTrafficRouting", 1) + `,`,
		`Plugins:` + mapStringForPlugins + `,`,
		`MaxTrafficWeight:` + valueToStringGenerated(this.MaxTrafficWeight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RouteMatch) String() string {
	if this == nil {
		return "nil"
	}
	keysForHeaders := make([]string, 0, len(this.Headers))
	for k := range this.Headers {
		keysForHeaders = append(keysForHeaders, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders)
	mapStringForHeaders := "map[string]StringMatch{"
	for _, k := range keysForHeaders {
		mapStringForHeaders += fmt.Sprintf("%v: %v,", k, this.Headers[k])
	}
	mapStringForHeaders += "}"
	s := strings.Join([]string{`&RouteMatch{`,
		`Method:` + strings.Replace(this.Method.String(), "StringMatch", "StringMatch", 1) + `,`,
		`Path:` + strings.Replace(this.Path.String(), "StringMatch", "StringMatch", 1) + `,`,
		`Headers:` + mapStringForHeaders + `,`,
		`}`,
	}, "")
	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 *SMITrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SMITrafficRouting{`,
		`RootService:` + fmt.Sprintf("%v", this.RootService) + `,`,
		`TrafficSplitName:` + fmt.Sprintf("%v", this.TrafficSplitName) + `,`,
		`}`,
	}, "")
	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 *SecretRef) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SecretRef{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Namespaced:` + fmt.Sprintf("%v", this.Namespaced) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetCanaryScale) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SetCanaryScale{`,
		`Weight:` + valueToStringGenerated(this.Weight) + `,`,
		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
		`MatchTrafficWeight:` + fmt.Sprintf("%v", this.MatchTrafficWeight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetHeaderRoute) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMatch := "[]HeaderRoutingMatch{"
	for _, f := range this.Match {
		repeatedStringForMatch += strings.Replace(strings.Replace(f.String(), "HeaderRoutingMatch", "HeaderRoutingMatch", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMatch += "}"
	s := strings.Join([]string{`&SetHeaderRoute{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Match:` + repeatedStringForMatch + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetMirrorRoute) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMatch := "[]RouteMatch{"
	for _, f := range this.Match {
		repeatedStringForMatch += strings.Replace(strings.Replace(f.String(), "RouteMatch", "RouteMatch", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMatch += "}"
	s := strings.Join([]string{`&SetMirrorRoute{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Match:` + repeatedStringForMatch + `,`,
		`Percentage:` + valueToStringGenerated(this.Percentage) + `,`,
		`}`,
	}, "")
	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 *StepPluginStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StepPluginStatus{`,
		`Index:` + fmt.Sprintf("%v", this.Index) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Operation:` + fmt.Sprintf("%v", this.Operation) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`StartedAt:` + strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Time", "v1.Time", 1) + `,`,
		`UpdatedAt:` + strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Time", "v1.Time", 1) + `,`,
		`FinishedAt:` + strings.Replace(fmt.Sprintf("%v", this.FinishedAt), "Time", "v1.Time", 1) + `,`,
		`Backoff:` + fmt.Sprintf("%v", this.Backoff) + `,`,
		`Executions:` + fmt.Sprintf("%v", this.Executions) + `,`,
		`Disabled:` + fmt.Sprintf("%v", this.Disabled) + `,`,
		`Status:` + valueToStringGenerated(this.Status) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StickinessConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StickinessConfig{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`DurationSeconds:` + fmt.Sprintf("%v", this.DurationSeconds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StringMatch) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StringMatch{`,
		`Exact:` + fmt.Sprintf("%v", this.Exact) + `,`,
		`Prefix:` + fmt.Sprintf("%v", this.Prefix) + `,`,
		`Regex:` + fmt.Sprintf("%v", this.Regex) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TCPRoute) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TCPRoute{`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TLSRoute) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TLSRoute{`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`SNIHosts:` + fmt.Sprintf("%v", this.SNIHosts) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TTLStrategy) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TTLStrategy{`,
		`SecondsAfterCompletion:` + valueToStringGenerated(this.SecondsAfterCompletion) + `,`,
		`SecondsAfterFailure:` + valueToStringGenerated(this.SecondsAfterFailure) + `,`,
		`SecondsAfterSuccess:` + valueToStringGenerated(this.SecondsAfterSuccess) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TemplateService) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TemplateService{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TemplateSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TemplateSpec{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
		`Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v12.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
		`Service:` + strings.Replace(this.Service.String(), "TemplateService", "TemplateService", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TemplateStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TemplateStatus{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`LastTransitionTime:` + strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1) + `,`,
		`ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
		`PodTemplateHash:` + fmt.Sprintf("%v", this.PodTemplateHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TraefikTrafficRouting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TraefikTrafficRouting{`,
		`WeightedTraefikServiceName:` + fmt.Sprintf("%v", this.WeightedTraefikServiceName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TrafficWeights) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAdditional := "[]WeightDestination{"
	for _, f := range this.Additional {
		repeatedStringForAdditional += strings.Replace(strings.Replace(f.String(), "WeightDestination", "WeightDestination", 1), `&`, ``, 1) + ","
	}
	repeatedStringForAdditional += "}"
	s := strings.Join([]string{`&TrafficWeights{`,
		`Canary:` + strings.Replace(strings.Replace(this.Canary.String(), "WeightDestination", "WeightDestination", 1), `&`, ``, 1) + `,`,
		`Stable:` + strings.Replace(strings.Replace(this.Stable.String(), "WeightDestination", "WeightDestination", 1), `&`, ``, 1) + `,`,
		`Additional:` + repeatedStringForAdditional + `,`,
		`Verified:` + valueToStringGenerated(this.Verified) + `,`,
		`}`,
	}, "")
	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 (this *WeightDestination) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WeightDestination{`,
		`Weight:` + fmt.Sprintf("%v", this.Weight) + `,`,
		`ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
		`PodTemplateHash:` + fmt.Sprintf("%v", this.PodTemplateHash) + `,`,
		`}`,
	}, "")
	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 *ALBStatus) 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: ALBStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ALBStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", 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.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanaryTargetGroup", 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.CanaryTargetGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableTargetGroup", 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.StableTargetGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", 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.Ingress = 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 *ALBTrafficRouting) 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: ALBTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ALBTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", 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.Ingress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
			}
			m.ServicePort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ServicePort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootService", 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.RootService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnnotationPrefix", 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.AnnotationPrefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StickinessConfig", 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.StickinessConfig == nil {
				m.StickinessConfig = &StickinessConfig{}
			}
			if err := m.StickinessConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ingresses", 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.Ingresses = append(m.Ingresses, 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 *AmbassadorTrafficRouting) 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: AmbassadorTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AmbassadorTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mappings", 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.Mappings = append(m.Mappings, 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 *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 *AnalysisRunArgument) 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: AnalysisRunArgument: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunArgument: 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
		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 = &ArgumentValueFrom{}
			}
			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 *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 *AnalysisRunMetadata) 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: AnalysisRunMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil {
				m.Labels = 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.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil {
				m.Annotations = 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.Annotations[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 *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
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTLStrategy", 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.TTLStrategy == nil {
				m.TTLStrategy = &TTLStrategy{}
			}
			if err := m.TTLStrategy.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
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletedAt", 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.CompletedAt == nil {
				m.CompletedAt = &v1.Time{}
			}
			if err := m.CompletedAt.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 *AnalysisRunStrategy) 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: AnalysisRunStrategy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SuccessfulRunHistoryLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SuccessfulRunHistoryLimit = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnsuccessfulRunHistoryLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UnsuccessfulRunHistoryLimit = &v
		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 *AnalysisTemplateRef) 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: AnalysisTemplateRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisTemplateRef: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemplateName", 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.TemplateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", 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.ClusterScope = bool(v != 0)
		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
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Templates", 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.Templates = append(m.Templates, AnalysisTemplateRef{})
			if err := m.Templates[len(m.Templates)-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 *AntiAffinity) 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: AntiAffinity: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AntiAffinity: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreferredDuringSchedulingIgnoredDuringExecution", 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.PreferredDuringSchedulingIgnoredDuringExecution == nil {
				m.PreferredDuringSchedulingIgnoredDuringExecution = &PreferredDuringSchedulingIgnoredDuringExecution{}
			}
			if err := m.PreferredDuringSchedulingIgnoredDuringExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredDuringSchedulingIgnoredDuringExecution", 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.RequiredDuringSchedulingIgnoredDuringExecution == nil {
				m.RequiredDuringSchedulingIgnoredDuringExecution = &RequiredDuringSchedulingIgnoredDuringExecution{}
			}
			if err := m.RequiredDuringSchedulingIgnoredDuringExecution.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 *ApisixRoute) 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: ApisixRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApisixRoute: 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 Rules", 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.Rules = append(m.Rules, 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 *ApisixTrafficRouting) 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: ApisixTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApisixTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Route", 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.Route == nil {
				m.Route = &ApisixRoute{}
			}
			if err := m.Route.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 *AppMeshTrafficRouting) 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: AppMeshTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppMeshTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualService", 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.VirtualService == nil {
				m.VirtualService = &AppMeshVirtualService{}
			}
			if err := m.VirtualService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualNodeGroup", 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.VirtualNodeGroup == nil {
				m.VirtualNodeGroup = &AppMeshVirtualNodeGroup{}
			}
			if err := m.VirtualNodeGroup.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 *AppMeshVirtualNodeGroup) 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: AppMeshVirtualNodeGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppMeshVirtualNodeGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanaryVirtualNodeRef", 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.CanaryVirtualNodeRef == nil {
				m.CanaryVirtualNodeRef = &AppMeshVirtualNodeReference{}
			}
			if err := m.CanaryVirtualNodeRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableVirtualNodeRef", 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.StableVirtualNodeRef == nil {
				m.StableVirtualNodeRef = &AppMeshVirtualNodeReference{}
			}
			if err := m.StableVirtualNodeRef.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 *AppMeshVirtualNodeReference) 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: AppMeshVirtualNodeReference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppMeshVirtualNodeReference: 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
		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 *AppMeshVirtualService) 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: AppMeshVirtualService: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppMeshVirtualService: 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 Routes", 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.Routes = append(m.Routes, 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 *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 *ArgumentValueFrom) 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: ArgumentValueFrom: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ArgumentValueFrom: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodTemplateHashValue", 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 := ValueFromPodTemplateHash(dAtA[iNdEx:postIndex])
			m.PodTemplateHashValue = &s
			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 *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 *AwsResourceRef) 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: AwsResourceRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AwsResourceRef: 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 ARN", 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.ARN = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullName", 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.FullName = 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 *BlueGreenStatus) 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: BlueGreenStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlueGreenStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviewSelector", 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.PreviewSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveSelector", 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.ActiveSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleUpPreviewCheckPoint", 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.ScaleUpPreviewCheckPoint = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrePromotionAnalysisRunStatus", 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.PrePromotionAnalysisRunStatus == nil {
				m.PrePromotionAnalysisRunStatus = &RolloutAnalysisRunStatus{}
			}
			if err := m.PrePromotionAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostPromotionAnalysisRunStatus", 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.PostPromotionAnalysisRunStatus == nil {
				m.PostPromotionAnalysisRunStatus = &RolloutAnalysisRunStatus{}
			}
			if err := m.PostPromotionAnalysisRunStatus.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 *BlueGreenStrategy) 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: BlueGreenStrategy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlueGreenStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveService", 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.ActiveService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviewService", 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.PreviewService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviewReplicaCount", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PreviewReplicaCount = &v
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoPromotionEnabled", 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.AutoPromotionEnabled = &b
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoPromotionSeconds", wireType)
			}
			m.AutoPromotionSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AutoPromotionSeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", 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.MaxUnavailable == nil {
				m.MaxUnavailable = &intstr.IntOrString{}
			}
			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScaleDownDelaySeconds = &v
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayRevisionLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScaleDownDelayRevisionLimit = &v
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrePromotionAnalysis", 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.PrePromotionAnalysis == nil {
				m.PrePromotionAnalysis = &RolloutAnalysis{}
			}
			if err := m.PrePromotionAnalysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AntiAffinity", 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.AntiAffinity == nil {
				m.AntiAffinity = &AntiAffinity{}
			}
			if err := m.AntiAffinity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostPromotionAnalysis", 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.PostPromotionAnalysis == nil {
				m.PostPromotionAnalysis = &RolloutAnalysis{}
			}
			if err := m.PostPromotionAnalysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviewMetadata", 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.PreviewMetadata == nil {
				m.PreviewMetadata = &PodTemplateMetadata{}
			}
			if err := m.PreviewMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveMetadata", 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.ActiveMetadata == nil {
				m.ActiveMetadata = &PodTemplateMetadata{}
			}
			if err := m.ActiveMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbortScaleDownDelaySeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AbortScaleDownDelaySeconds = &v
		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 *CanaryStatus) 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: CanaryStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CanaryStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentStepAnalysisRunStatus", 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.CurrentStepAnalysisRunStatus == nil {
				m.CurrentStepAnalysisRunStatus = &RolloutAnalysisRunStatus{}
			}
			if err := m.CurrentStepAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentBackgroundAnalysisRunStatus", 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.CurrentBackgroundAnalysisRunStatus == nil {
				m.CurrentBackgroundAnalysisRunStatus = &RolloutAnalysisRunStatus{}
			}
			if err := m.CurrentBackgroundAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentExperiment", 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.CurrentExperiment = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weights", 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.Weights == nil {
				m.Weights = &TrafficWeights{}
			}
			if err := m.Weights.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StablePingPong", 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.StablePingPong = PingPongType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepPluginStatuses", 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.StepPluginStatuses = append(m.StepPluginStatuses, StepPluginStatus{})
			if err := m.StepPluginStatuses[len(m.StepPluginStatuses)-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 *CanaryStep) 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: CanaryStep: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CanaryStep: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetWeight", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SetWeight = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pause", 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.Pause == nil {
				m.Pause = &RolloutPause{}
			}
			if err := m.Pause.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Experiment", 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.Experiment == nil {
				m.Experiment = &RolloutExperimentStep{}
			}
			if err := m.Experiment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analysis", 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.Analysis == nil {
				m.Analysis = &RolloutAnalysis{}
			}
			if err := m.Analysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetCanaryScale", 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.SetCanaryScale == nil {
				m.SetCanaryScale = &SetCanaryScale{}
			}
			if err := m.SetCanaryScale.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetHeaderRoute", 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.SetHeaderRoute == nil {
				m.SetHeaderRoute = &SetHeaderRoute{}
			}
			if err := m.SetHeaderRoute.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetMirrorRoute", 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.SetMirrorRoute == nil {
				m.SetMirrorRoute = &SetMirrorRoute{}
			}
			if err := m.SetMirrorRoute.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			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 = &PluginStep{}
			}
			if err := m.Plugin.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 *CanaryStrategy) 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: CanaryStrategy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CanaryStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanaryService", 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.CanaryService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableService", 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.StableService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Steps", 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.Steps = append(m.Steps, CanaryStep{})
			if err := m.Steps[len(m.Steps)-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 TrafficRouting", 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.TrafficRouting == nil {
				m.TrafficRouting = &RolloutTrafficRouting{}
			}
			if err := m.TrafficRouting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", 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.MaxUnavailable == nil {
				m.MaxUnavailable = &intstr.IntOrString{}
			}
			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", 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.MaxSurge == nil {
				m.MaxSurge = &intstr.IntOrString{}
			}
			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analysis", 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.Analysis == nil {
				m.Analysis = &RolloutAnalysisBackground{}
			}
			if err := m.Analysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AntiAffinity", 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.AntiAffinity == nil {
				m.AntiAffinity = &AntiAffinity{}
			}
			if err := m.AntiAffinity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanaryMetadata", 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.CanaryMetadata == nil {
				m.CanaryMetadata = &PodTemplateMetadata{}
			}
			if err := m.CanaryMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableMetadata", 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.StableMetadata == nil {
				m.StableMetadata = &PodTemplateMetadata{}
			}
			if err := m.StableMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScaleDownDelaySeconds = &v
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayRevisionLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScaleDownDelayRevisionLimit = &v
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbortScaleDownDelaySeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AbortScaleDownDelaySeconds = &v
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DynamicStableScale", 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.DynamicStableScale = bool(v != 0)
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PingPong", 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.PingPong == nil {
				m.PingPong = &PingPongSpec{}
			}
			if err := m.PingPong.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinPodsPerReplicaSet", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MinPodsPerReplicaSet = &v
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaProgressThreshold", 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.ReplicaProgressThreshold == nil {
				m.ReplicaProgressThreshold = &ReplicaProgressThreshold{}
			}
			if err := m.ReplicaProgressThreshold.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 *ClusterAnalysisTemplate) 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: ClusterAnalysisTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterAnalysisTemplate: 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 *ClusterAnalysisTemplateList) 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: ClusterAnalysisTemplateList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterAnalysisTemplateList: 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, ClusterAnalysisTemplate{})
			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 *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
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Aggregator", 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.Aggregator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", 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.SecretRef.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 *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 *Experiment) 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: Experiment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Experiment: 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 *ExperimentAnalysisRunStatus) 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: ExperimentAnalysisRunStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentAnalysisRunStatus: 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 AnalysisRun", 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.AnalysisRun = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 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
		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 *ExperimentAnalysisTemplateRef) 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: ExperimentAnalysisTemplateRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentAnalysisTemplateRef: 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 TemplateName", 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.TemplateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", 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.ClusterScope = bool(v != 0)
		case 4:
			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 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredForCompletion", 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.RequiredForCompletion = bool(v != 0)
		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 *ExperimentCondition) 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: ExperimentCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", 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.Type = ExperimentConditionType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", 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.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", 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.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", 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.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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
		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 *ExperimentList) 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: ExperimentList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentList: 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, Experiment{})
			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 *ExperimentSpec) 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: ExperimentSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Templates", 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.Templates = append(m.Templates, TemplateSpec{})
			if err := m.Templates[len(m.Templates)-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 Duration", 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.Duration = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ProgressDeadlineSeconds = &v
		case 4:
			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 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analyses", 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.Analyses = append(m.Analyses, ExperimentAnalysisTemplateRef{})
			if err := m.Analyses[len(m.Analyses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScaleDownDelaySeconds = &v
		case 7:
			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 8:
			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
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnalysisRunMetadata", 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.AnalysisRunMetadata.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 *ExperimentStatus) 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: ExperimentStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentStatus: 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 TemplateStatuses", 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.TemplateStatuses = append(m.TemplateStatuses, TemplateStatus{})
			if err := m.TemplateStatuses[len(m.TemplateStatuses)-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 AvailableAt", 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.AvailableAt == nil {
				m.AvailableAt = &v1.Time{}
			}
			if err := m.AvailableAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", 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.Conditions = append(m.Conditions, ExperimentCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnalysisRuns", 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.AnalysisRuns = append(m.AnalysisRuns, ExperimentAnalysisRunStatus{})
			if err := m.AnalysisRuns[len(m.AnalysisRuns)-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 *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 *HeaderRoutingMatch) 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: HeaderRoutingMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeaderRoutingMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderName", 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.HeaderName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderValue", 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.HeaderValue == nil {
				m.HeaderValue = &StringMatch{}
			}
			if err := m.HeaderValue.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 *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 *IstioDestinationRule) 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: IstioDestinationRule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IstioDestinationRule: 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 CanarySubsetName", 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.CanarySubsetName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableSubsetName", 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.StableSubsetName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdditionalSubsetNames", 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.AdditionalSubsetNames = append(m.AdditionalSubsetNames, 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 *IstioTrafficRouting) 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: IstioTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IstioTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualService", 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.VirtualService == nil {
				m.VirtualService = &IstioVirtualService{}
			}
			if err := m.VirtualService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationRule", 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.DestinationRule == nil {
				m.DestinationRule = &IstioDestinationRule{}
			}
			if err := m.DestinationRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualServices", 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.VirtualServices = append(m.VirtualServices, IstioVirtualService{})
			if err := m.VirtualServices[len(m.VirtualServices)-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 *IstioVirtualService) 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: IstioVirtualService: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IstioVirtualService: 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 Routes", 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.Routes = append(m.Routes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TLSRoutes", 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.TLSRoutes = append(m.TLSRoutes, TLSRoute{})
			if err := m.TLSRoutes[len(m.TLSRoutes)-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 TCPRoutes", 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.TCPRoutes = append(m.TCPRoutes, TCPRoute{})
			if err := m.TCPRoutes[len(m.TCPRoutes)-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 *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
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lookback", 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.Lookback = bool(v != 0)
		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 *MangedRoutes) 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: MangedRoutes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MangedRoutes: 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
		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
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveSuccessLimit", 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.ConsecutiveSuccessLimit == nil {
				m.ConsecutiveSuccessLimit = &intstr.IntOrString{}
			}
			if err := m.ConsecutiveSuccessLimit.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
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveSuccess", wireType)
			}
			m.ConsecutiveSuccess = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConsecutiveSuccess |= 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 *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
		case 3:
			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
		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 *NginxTrafficRouting) 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: NginxTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NginxTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnnotationPrefix", 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.AnnotationPrefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableIngress", 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.StableIngress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdditionalIngressAnnotations", 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.AdditionalIngressAnnotations == nil {
				m.AdditionalIngressAnnotations = 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.AdditionalIngressAnnotations[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableIngresses", 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.StableIngresses = append(m.StableIngresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanaryIngressAnnotations", 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.CanaryIngressAnnotations == nil {
				m.CanaryIngressAnnotations = 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.CanaryIngressAnnotations[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 *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 *ObjectRef) 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: ObjectRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectRef: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", 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.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDown", 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.ScaleDown = 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 *PauseCondition) 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: PauseCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PauseCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", 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.Reason = PauseReason(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", 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.StartTime.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 *PingPongSpec) 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: PingPongSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingPongSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PingService", 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.PingService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PongService", 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.PongService = 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 *PluginStep) 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: PluginStep: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PluginStep: 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 Config", 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.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...)
			if m.Config == nil {
				m.Config = []byte{}
			}
			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 *PodTemplateMetadata) 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: PodTemplateMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodTemplateMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil {
				m.Labels = 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.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil {
				m.Annotations = 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.Annotations[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 *PreferredDuringSchedulingIgnoredDuringExecution) 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: PreferredDuringSchedulingIgnoredDuringExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PreferredDuringSchedulingIgnoredDuringExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= 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 *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
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeQuery", 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.RangeQuery == nil {
				m.RangeQuery = &PrometheusRangeQueryArgs{}
			}
			if err := m.RangeQuery.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 *PrometheusRangeQueryArgs) 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: PrometheusRangeQueryArgs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PrometheusRangeQueryArgs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			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
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Step", 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.Step = 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 *ReplicaProgressThreshold) 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: ReplicaProgressThreshold: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaProgressThreshold: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", 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.Type = ProgressType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= 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 *RequiredDuringSchedulingIgnoredDuringExecution) 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: RequiredDuringSchedulingIgnoredDuringExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequiredDuringSchedulingIgnoredDuringExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 *RollbackWindowSpec) 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: RollbackWindowSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RollbackWindowSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revisions", wireType)
			}
			m.Revisions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revisions |= 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 *Rollout) 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: Rollout: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rollout: 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 *RolloutAnalysis) 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: RolloutAnalysis: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutAnalysis: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Templates", 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.Templates = append(m.Templates, AnalysisTemplateRef{})
			if err := m.Templates[len(m.Templates)-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, AnalysisRunArgument{})
			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
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnalysisRunMetadata", 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.AnalysisRunMetadata.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 *RolloutAnalysisBackground) 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: RolloutAnalysisBackground: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutAnalysisBackground: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RolloutAnalysis", 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.RolloutAnalysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartingStep", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StartingStep = &v
		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 *RolloutAnalysisRunStatus) 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: RolloutAnalysisRunStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutAnalysisRunStatus: 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 Status", 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.Status = AnalysisPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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
		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 *RolloutCondition) 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: RolloutCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", 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.Type = RolloutConditionType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", 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.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", 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.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", 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.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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
		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 *RolloutExperimentStep) 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: RolloutExperimentStep: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutExperimentStep: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Templates", 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.Templates = append(m.Templates, RolloutExperimentTemplate{})
			if err := m.Templates[len(m.Templates)-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 Duration", 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.Duration = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analyses", 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.Analyses = append(m.Analyses, RolloutExperimentStepAnalysisTemplateRef{})
			if err := m.Analyses[len(m.Analyses)-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 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 AnalysisRunMetadata", 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.AnalysisRunMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScaleDownDelaySeconds = &v
		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 *RolloutExperimentStepAnalysisTemplateRef) 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: RolloutExperimentStepAnalysisTemplateRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutExperimentStepAnalysisTemplateRef: 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 TemplateName", 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.TemplateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", 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.ClusterScope = bool(v != 0)
		case 4:
			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, AnalysisRunArgument{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredForCompletion", 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.RequiredForCompletion = bool(v != 0)
		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 *RolloutExperimentTemplate) 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: RolloutExperimentTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutExperimentTemplate: 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 SpecRef", 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.SpecRef = ReplicaSetSpecRef(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Replicas = &v
		case 4:
			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 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", 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.Selector == nil {
				m.Selector = &v1.LabelSelector{}
			}
			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Weight = &v
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", 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.Service == nil {
				m.Service = &TemplateService{}
			}
			if err := m.Service.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 *RolloutList) 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: RolloutList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutList: 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, Rollout{})
			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 *RolloutPause) 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: RolloutPause: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutPause: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", 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.Duration == nil {
				m.Duration = &intstr.IntOrString{}
			}
			if err := m.Duration.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 *RolloutSpec) 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: RolloutSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Replicas = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", 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.Selector == nil {
				m.Selector = &v1.LabelSelector{}
			}
			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Template", 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.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
			}
			m.MinReadySeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinReadySeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", 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.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RevisionHistoryLimit = &v
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paused", 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.Paused = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ProgressDeadlineSeconds = &v
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartAt", 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.RestartAt == nil {
				m.RestartAt = &v1.Time{}
			}
			if err := m.RestartAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadRef", 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.WorkloadRef == nil {
				m.WorkloadRef = &ObjectRef{}
			}
			if err := m.WorkloadRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analysis", 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.Analysis == nil {
				m.Analysis = &AnalysisRunStrategy{}
			}
			if err := m.Analysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineAbort", 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.ProgressDeadlineAbort = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollbackWindow", 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.RollbackWindow == nil {
				m.RollbackWindow = &RollbackWindowSpec{}
			}
			if err := m.RollbackWindow.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 *RolloutStatus) 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: RolloutStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Abort", 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.Abort = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PauseConditions", 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.PauseConditions = append(m.PauseConditions, PauseCondition{})
			if err := m.PauseConditions[len(m.PauseConditions)-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 ControllerPause", 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.ControllerPause = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbortedAt", 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.AbortedAt == nil {
				m.AbortedAt = &v1.Time{}
			}
			if err := m.AbortedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentPodHash", 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.CurrentPodHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentStepHash", 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.CurrentStepHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
			}
			m.UpdatedReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
			}
			m.ReadyReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadyReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
			}
			m.AvailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentStepIndex", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CurrentStepIndex = &v
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CollisionCount = &v
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", 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.ObservedGeneration = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", 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.Conditions = append(m.Conditions, RolloutCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Canary", 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.Canary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlueGreen", 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.BlueGreen.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HPAReplicas", wireType)
			}
			m.HPAReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HPAReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", 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.Selector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableRS", 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.StableRS = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartedAt", 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.RestartedAt == nil {
				m.RestartedAt = &v1.Time{}
			}
			if err := m.RestartedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PromoteFull", 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.PromoteFull = bool(v != 0)
		case 22:
			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 = RolloutPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 23:
			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 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadObservedGeneration", 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.WorkloadObservedGeneration = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ALB", 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.ALB == nil {
				m.ALB = &ALBStatus{}
			}
			if err := m.ALB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ALBs", 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.ALBs = append(m.ALBs, ALBStatus{})
			if err := m.ALBs[len(m.ALBs)-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 *RolloutStrategy) 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: RolloutStrategy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlueGreen", 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.BlueGreen == nil {
				m.BlueGreen = &BlueGreenStrategy{}
			}
			if err := m.BlueGreen.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Canary", 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.Canary == nil {
				m.Canary = &CanaryStrategy{}
			}
			if err := m.Canary.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 *RolloutTrafficRouting) 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: RolloutTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Istio", 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.Istio == nil {
				m.Istio = &IstioTrafficRouting{}
			}
			if err := m.Istio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nginx", 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.Nginx == nil {
				m.Nginx = &NginxTrafficRouting{}
			}
			if err := m.Nginx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ALB", 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.ALB == nil {
				m.ALB = &ALBTrafficRouting{}
			}
			if err := m.ALB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SMI", 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.SMI == nil {
				m.SMI = &SMITrafficRouting{}
			}
			if err := m.SMI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ambassador", 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.Ambassador == nil {
				m.Ambassador = &AmbassadorTrafficRouting{}
			}
			if err := m.Ambassador.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppMesh", 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.AppMesh == nil {
				m.AppMesh = &AppMeshTrafficRouting{}
			}
			if err := m.AppMesh.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Traefik", 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.Traefik == nil {
				m.Traefik = &TraefikTrafficRouting{}
			}
			if err := m.Traefik.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ManagedRoutes", 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.ManagedRoutes = append(m.ManagedRoutes, MangedRoutes{})
			if err := m.ManagedRoutes[len(m.ManagedRoutes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Apisix", 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.Apisix == nil {
				m.Apisix = &ApisixTrafficRouting{}
			}
			if err := m.Apisix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Plugins", 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.Plugins == nil {
				m.Plugins = 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.Plugins[mapkey] = ((encoding_json.RawMessage)(mapvalue))
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTrafficWeight", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MaxTrafficWeight = &v
		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 *RouteMatch) 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: RouteMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteMatch: 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 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.Method == nil {
				m.Method = &StringMatch{}
			}
			if err := m.Method.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", 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.Path == nil {
				m.Path = &StringMatch{}
			}
			if err := m.Path.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
			}
			if m.Headers == nil {
				m.Headers = make(map[string]StringMatch)
			}
			var mapkey string
			mapvalue := &StringMatch{}
			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 mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGenerated
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGenerated
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &StringMatch{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} 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.Headers[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 *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 *SMITrafficRouting) 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: SMITrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SMITrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootService", 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.RootService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrafficSplitName", 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.TrafficSplitName = 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 *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 *SecretRef) 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: SecretRef: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SecretRef: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespaced", 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.Namespaced = bool(v != 0)
		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 *SetCanaryScale) 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: SetCanaryScale: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetCanaryScale: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Weight = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Replicas = &v
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchTrafficWeight", 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.MatchTrafficWeight = bool(v != 0)
		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 *SetHeaderRoute) 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: SetHeaderRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetHeaderRoute: 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 Match", 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.Match = append(m.Match, HeaderRoutingMatch{})
			if err := m.Match[len(m.Match)-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 *SetMirrorRoute) 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: SetMirrorRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetMirrorRoute: 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 Match", 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.Match = append(m.Match, RouteMatch{})
			if err := m.Match[len(m.Match)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentage", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Percentage = &v
		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 *StepPluginStatus) 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: StepPluginStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StepPluginStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operation", 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.Operation = StepPluginOperation(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 = StepPluginPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 6:
			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 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", 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.UpdatedAt == nil {
				m.UpdatedAt = &v1.Time{}
			}
			if err := m.UpdatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			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 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Backoff", 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.Backoff = DurationString(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executions", wireType)
			}
			m.Executions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Executions |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Disabled", 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.Disabled = bool(v != 0)
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status = append(m.Status[:0], dAtA[iNdEx:postIndex]...)
			if m.Status == nil {
				m.Status = []byte{}
			}
			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 *StickinessConfig) 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: StickinessConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StickinessConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", 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.Enabled = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DurationSeconds", wireType)
			}
			m.DurationSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DurationSeconds |= 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 *StringMatch) 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: StringMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exact", 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.Exact = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", 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.Prefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regex", 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.Regex = 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 *TCPRoute) 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: TCPRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TCPRoute: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= 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 *TLSRoute) 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: TLSRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TLSRoute: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SNIHosts", 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.SNIHosts = append(m.SNIHosts, 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 *TTLStrategy) 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: TTLStrategy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TTLStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondsAfterCompletion", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SecondsAfterCompletion = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondsAfterFailure", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SecondsAfterFailure = &v
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondsAfterSuccess", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SecondsAfterSuccess = &v
		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 *TemplateService) 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: TemplateService: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TemplateService: 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
		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 *TemplateSpec) 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: TemplateSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TemplateSpec: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Replicas = &v
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
			}
			m.MinReadySeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinReadySeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", 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.Selector == nil {
				m.Selector = &v1.LabelSelector{}
			}
			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Template", 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.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", 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.Service == nil {
				m.Service = &TemplateService{}
			}
			if err := m.Service.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 *TemplateStatus) 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: TemplateStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TemplateStatus: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
			}
			m.UpdatedReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
			}
			m.ReadyReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadyReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
			}
			m.AvailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CollisionCount = &v
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status = TemplateStatusCode(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			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 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", 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.LastTransitionTime == nil {
				m.LastTransitionTime = &v1.Time{}
			}
			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", 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.ServiceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodTemplateHash", 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.PodTemplateHash = 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 *TraefikTrafficRouting) 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: TraefikTrafficRouting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TraefikTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeightedTraefikServiceName", 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.WeightedTraefikServiceName = 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 *TrafficWeights) 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: TrafficWeights: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TrafficWeights: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Canary", 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.Canary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stable", 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.Stable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Additional", 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.Additional = append(m.Additional, WeightDestination{})
			if err := m.Additional[len(m.Additional)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Verified", 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.Verified = &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 *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 (m *WeightDestination) 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: WeightDestination: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WeightDestination: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", 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.ServiceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodTemplateHash", 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.PodTemplateHash = 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")
)
