// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/apiclient/rollout/rollout.proto

package rollout

import (
	context "context"
	fmt "fmt"
	v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	io "io"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	math "math"
	math_bits "math/bits"
)

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

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

type RolloutInfoQuery struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RolloutInfoQuery proto.InternalMessageInfo

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

func (m *RolloutInfoQuery) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type RolloutInfoListQuery struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RolloutInfoListQuery proto.InternalMessageInfo

func (m *RolloutInfoListQuery) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type SetImageRequest struct {
	Rollout              string   `protobuf:"bytes,1,opt,name=rollout,proto3" json:"rollout,omitempty"`
	Container            string   `protobuf:"bytes,2,opt,name=container,proto3" json:"container,omitempty"`
	Image                string   `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"`
	Tag                  string   `protobuf:"bytes,4,opt,name=tag,proto3" json:"tag,omitempty"`
	Namespace            string   `protobuf:"bytes,5,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SetImageRequest proto.InternalMessageInfo

func (m *SetImageRequest) GetRollout() string {
	if m != nil {
		return m.Rollout
	}
	return ""
}

func (m *SetImageRequest) GetContainer() string {
	if m != nil {
		return m.Container
	}
	return ""
}

func (m *SetImageRequest) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

func (m *SetImageRequest) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *SetImageRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type UndoRolloutRequest struct {
	Rollout              string   `protobuf:"bytes,1,opt,name=rollout,proto3" json:"rollout,omitempty"`
	Revision             int64    `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Namespace            string   `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UndoRolloutRequest proto.InternalMessageInfo

func (m *UndoRolloutRequest) GetRollout() string {
	if m != nil {
		return m.Rollout
	}
	return ""
}

func (m *UndoRolloutRequest) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *UndoRolloutRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type RestartRolloutRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RestartRolloutRequest proto.InternalMessageInfo

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

func (m *RestartRolloutRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type PromoteRolloutRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Full                 bool     `protobuf:"varint,3,opt,name=full,proto3" json:"full,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PromoteRolloutRequest proto.InternalMessageInfo

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

func (m *PromoteRolloutRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *PromoteRolloutRequest) GetFull() bool {
	if m != nil {
		return m.Full
	}
	return false
}

type AbortRolloutRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AbortRolloutRequest proto.InternalMessageInfo

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

func (m *AbortRolloutRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type RetryRolloutRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RetryRolloutRequest proto.InternalMessageInfo

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

func (m *RetryRolloutRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type RolloutWatchEvent struct {
	Type                 string       `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	RolloutInfo          *RolloutInfo `protobuf:"bytes,2,opt,name=rolloutInfo,proto3" json:"rolloutInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_RolloutWatchEvent proto.InternalMessageInfo

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

func (m *RolloutWatchEvent) GetRolloutInfo() *RolloutInfo {
	if m != nil {
		return m.RolloutInfo
	}
	return nil
}

type NamespaceInfo struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	AvailableNamespaces  []string `protobuf:"bytes,2,rep,name=availableNamespaces,proto3" json:"availableNamespaces,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NamespaceInfo proto.InternalMessageInfo

func (m *NamespaceInfo) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *NamespaceInfo) GetAvailableNamespaces() []string {
	if m != nil {
		return m.AvailableNamespaces
	}
	return nil
}

type RolloutInfoList struct {
	Rollouts             []*RolloutInfo `protobuf:"bytes,1,rep,name=rollouts,proto3" json:"rollouts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_RolloutInfoList proto.InternalMessageInfo

func (m *RolloutInfoList) GetRollouts() []*RolloutInfo {
	if m != nil {
		return m.Rollouts
	}
	return nil
}

type VersionInfo struct {
	RolloutsVersion      string   `protobuf:"bytes,1,opt,name=rolloutsVersion,proto3" json:"rolloutsVersion,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_VersionInfo proto.InternalMessageInfo

func (m *VersionInfo) GetRolloutsVersion() string {
	if m != nil {
		return m.RolloutsVersion
	}
	return ""
}

type RolloutInfo struct {
	ObjectMeta           *v1.ObjectMeta         `protobuf:"bytes,1,opt,name=objectMeta,proto3" json:"objectMeta,omitempty"`
	Status               string                 `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	Message              string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Icon                 string                 `protobuf:"bytes,4,opt,name=icon,proto3" json:"icon,omitempty"`
	Strategy             string                 `protobuf:"bytes,5,opt,name=strategy,proto3" json:"strategy,omitempty"`
	Step                 string                 `protobuf:"bytes,6,opt,name=step,proto3" json:"step,omitempty"`
	SetWeight            string                 `protobuf:"bytes,7,opt,name=setWeight,proto3" json:"setWeight,omitempty"`
	ActualWeight         string                 `protobuf:"bytes,8,opt,name=actualWeight,proto3" json:"actualWeight,omitempty"`
	Ready                int32                  `protobuf:"varint,9,opt,name=ready,proto3" json:"ready,omitempty"`
	Current              int32                  `protobuf:"varint,10,opt,name=current,proto3" json:"current,omitempty"`
	Desired              int32                  `protobuf:"varint,11,opt,name=desired,proto3" json:"desired,omitempty"`
	Updated              int32                  `protobuf:"varint,12,opt,name=updated,proto3" json:"updated,omitempty"`
	Available            int32                  `protobuf:"varint,13,opt,name=available,proto3" json:"available,omitempty"`
	RestartedAt          string                 `protobuf:"bytes,14,opt,name=restartedAt,proto3" json:"restartedAt,omitempty"`
	Generation           string                 `protobuf:"bytes,15,opt,name=generation,proto3" json:"generation,omitempty"`
	ReplicaSets          []*ReplicaSetInfo      `protobuf:"bytes,16,rep,name=replicaSets,proto3" json:"replicaSets,omitempty"`
	Experiments          []*ExperimentInfo      `protobuf:"bytes,17,rep,name=experiments,proto3" json:"experiments,omitempty"`
	AnalysisRuns         []*AnalysisRunInfo     `protobuf:"bytes,18,rep,name=analysisRuns,proto3" json:"analysisRuns,omitempty"`
	Containers           []*ContainerInfo       `protobuf:"bytes,19,rep,name=containers,proto3" json:"containers,omitempty"`
	Steps                []*v1alpha1.CanaryStep `protobuf:"bytes,20,rep,name=steps,proto3" json:"steps,omitempty"`
	InitContainers       []*ContainerInfo       `protobuf:"bytes,21,rep,name=initContainers,proto3" json:"initContainers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_RolloutInfo proto.InternalMessageInfo

func (m *RolloutInfo) GetObjectMeta() *v1.ObjectMeta {
	if m != nil {
		return m.ObjectMeta
	}
	return nil
}

func (m *RolloutInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *RolloutInfo) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *RolloutInfo) GetIcon() string {
	if m != nil {
		return m.Icon
	}
	return ""
}

func (m *RolloutInfo) GetStrategy() string {
	if m != nil {
		return m.Strategy
	}
	return ""
}

func (m *RolloutInfo) GetStep() string {
	if m != nil {
		return m.Step
	}
	return ""
}

func (m *RolloutInfo) GetSetWeight() string {
	if m != nil {
		return m.SetWeight
	}
	return ""
}

func (m *RolloutInfo) GetActualWeight() string {
	if m != nil {
		return m.ActualWeight
	}
	return ""
}

func (m *RolloutInfo) GetReady() int32 {
	if m != nil {
		return m.Ready
	}
	return 0
}

func (m *RolloutInfo) GetCurrent() int32 {
	if m != nil {
		return m.Current
	}
	return 0
}

func (m *RolloutInfo) GetDesired() int32 {
	if m != nil {
		return m.Desired
	}
	return 0
}

func (m *RolloutInfo) GetUpdated() int32 {
	if m != nil {
		return m.Updated
	}
	return 0
}

func (m *RolloutInfo) GetAvailable() int32 {
	if m != nil {
		return m.Available
	}
	return 0
}

func (m *RolloutInfo) GetRestartedAt() string {
	if m != nil {
		return m.RestartedAt
	}
	return ""
}

func (m *RolloutInfo) GetGeneration() string {
	if m != nil {
		return m.Generation
	}
	return ""
}

func (m *RolloutInfo) GetReplicaSets() []*ReplicaSetInfo {
	if m != nil {
		return m.ReplicaSets
	}
	return nil
}

func (m *RolloutInfo) GetExperiments() []*ExperimentInfo {
	if m != nil {
		return m.Experiments
	}
	return nil
}

func (m *RolloutInfo) GetAnalysisRuns() []*AnalysisRunInfo {
	if m != nil {
		return m.AnalysisRuns
	}
	return nil
}

func (m *RolloutInfo) GetContainers() []*ContainerInfo {
	if m != nil {
		return m.Containers
	}
	return nil
}

func (m *RolloutInfo) GetSteps() []*v1alpha1.CanaryStep {
	if m != nil {
		return m.Steps
	}
	return nil
}

func (m *RolloutInfo) GetInitContainers() []*ContainerInfo {
	if m != nil {
		return m.InitContainers
	}
	return nil
}

type ExperimentInfo struct {
	ObjectMeta           *v1.ObjectMeta     `protobuf:"bytes,1,opt,name=objectMeta,proto3" json:"objectMeta,omitempty"`
	Icon                 string             `protobuf:"bytes,2,opt,name=icon,proto3" json:"icon,omitempty"`
	Revision             int64              `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
	Status               string             `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	Message              string             `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	ReplicaSets          []*ReplicaSetInfo  `protobuf:"bytes,6,rep,name=replicaSets,proto3" json:"replicaSets,omitempty"`
	AnalysisRuns         []*AnalysisRunInfo `protobuf:"bytes,7,rep,name=analysisRuns,proto3" json:"analysisRuns,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_ExperimentInfo proto.InternalMessageInfo

func (m *ExperimentInfo) GetObjectMeta() *v1.ObjectMeta {
	if m != nil {
		return m.ObjectMeta
	}
	return nil
}

func (m *ExperimentInfo) GetIcon() string {
	if m != nil {
		return m.Icon
	}
	return ""
}

func (m *ExperimentInfo) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *ExperimentInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *ExperimentInfo) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *ExperimentInfo) GetReplicaSets() []*ReplicaSetInfo {
	if m != nil {
		return m.ReplicaSets
	}
	return nil
}

func (m *ExperimentInfo) GetAnalysisRuns() []*AnalysisRunInfo {
	if m != nil {
		return m.AnalysisRuns
	}
	return nil
}

type ReplicaSetInfo struct {
	ObjectMeta           *v1.ObjectMeta `protobuf:"bytes,1,opt,name=objectMeta,proto3" json:"objectMeta,omitempty"`
	Status               string         `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	Icon                 string         `protobuf:"bytes,3,opt,name=icon,proto3" json:"icon,omitempty"`
	Revision             int64          `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
	Stable               bool           `protobuf:"varint,5,opt,name=stable,proto3" json:"stable,omitempty"`
	Canary               bool           `protobuf:"varint,6,opt,name=canary,proto3" json:"canary,omitempty"`
	Active               bool           `protobuf:"varint,7,opt,name=active,proto3" json:"active,omitempty"`
	Preview              bool           `protobuf:"varint,8,opt,name=preview,proto3" json:"preview,omitempty"`
	Replicas             int32          `protobuf:"varint,9,opt,name=replicas,proto3" json:"replicas,omitempty"`
	Available            int32          `protobuf:"varint,10,opt,name=available,proto3" json:"available,omitempty"`
	Template             string         `protobuf:"bytes,11,opt,name=template,proto3" json:"template,omitempty"`
	ScaleDownDeadline    string         `protobuf:"bytes,12,opt,name=scaleDownDeadline,proto3" json:"scaleDownDeadline,omitempty"`
	Images               []string       `protobuf:"bytes,13,rep,name=images,proto3" json:"images,omitempty"`
	Pods                 []*PodInfo     `protobuf:"bytes,14,rep,name=pods,proto3" json:"pods,omitempty"`
	Ping                 bool           `protobuf:"varint,15,opt,name=ping,proto3" json:"ping,omitempty"`
	Pong                 bool           `protobuf:"varint,16,opt,name=pong,proto3" json:"pong,omitempty"`
	InitContainerImages  []string       `protobuf:"bytes,17,rep,name=initContainerImages,proto3" json:"initContainerImages,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_ReplicaSetInfo proto.InternalMessageInfo

func (m *ReplicaSetInfo) GetObjectMeta() *v1.ObjectMeta {
	if m != nil {
		return m.ObjectMeta
	}
	return nil
}

func (m *ReplicaSetInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *ReplicaSetInfo) GetIcon() string {
	if m != nil {
		return m.Icon
	}
	return ""
}

func (m *ReplicaSetInfo) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *ReplicaSetInfo) GetStable() bool {
	if m != nil {
		return m.Stable
	}
	return false
}

func (m *ReplicaSetInfo) GetCanary() bool {
	if m != nil {
		return m.Canary
	}
	return false
}

func (m *ReplicaSetInfo) GetActive() bool {
	if m != nil {
		return m.Active
	}
	return false
}

func (m *ReplicaSetInfo) GetPreview() bool {
	if m != nil {
		return m.Preview
	}
	return false
}

func (m *ReplicaSetInfo) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *ReplicaSetInfo) GetAvailable() int32 {
	if m != nil {
		return m.Available
	}
	return 0
}

func (m *ReplicaSetInfo) GetTemplate() string {
	if m != nil {
		return m.Template
	}
	return ""
}

func (m *ReplicaSetInfo) GetScaleDownDeadline() string {
	if m != nil {
		return m.ScaleDownDeadline
	}
	return ""
}

func (m *ReplicaSetInfo) GetImages() []string {
	if m != nil {
		return m.Images
	}
	return nil
}

func (m *ReplicaSetInfo) GetPods() []*PodInfo {
	if m != nil {
		return m.Pods
	}
	return nil
}

func (m *ReplicaSetInfo) GetPing() bool {
	if m != nil {
		return m.Ping
	}
	return false
}

func (m *ReplicaSetInfo) GetPong() bool {
	if m != nil {
		return m.Pong
	}
	return false
}

func (m *ReplicaSetInfo) GetInitContainerImages() []string {
	if m != nil {
		return m.InitContainerImages
	}
	return nil
}

type PodInfo struct {
	ObjectMeta           *v1.ObjectMeta `protobuf:"bytes,1,opt,name=objectMeta,proto3" json:"objectMeta,omitempty"`
	Status               string         `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	Icon                 string         `protobuf:"bytes,3,opt,name=icon,proto3" json:"icon,omitempty"`
	Ready                string         `protobuf:"bytes,4,opt,name=ready,proto3" json:"ready,omitempty"`
	Restarts             int32          `protobuf:"varint,5,opt,name=restarts,proto3" json:"restarts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_PodInfo proto.InternalMessageInfo

func (m *PodInfo) GetObjectMeta() *v1.ObjectMeta {
	if m != nil {
		return m.ObjectMeta
	}
	return nil
}

func (m *PodInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *PodInfo) GetIcon() string {
	if m != nil {
		return m.Icon
	}
	return ""
}

func (m *PodInfo) GetReady() string {
	if m != nil {
		return m.Ready
	}
	return ""
}

func (m *PodInfo) GetRestarts() int32 {
	if m != nil {
		return m.Restarts
	}
	return 0
}

type ContainerInfo struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Image                string   `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ContainerInfo proto.InternalMessageInfo

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

func (m *ContainerInfo) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

type JobInfo struct {
	ObjectMeta           *v1.ObjectMeta `protobuf:"bytes,1,opt,name=objectMeta,proto3" json:"objectMeta,omitempty"`
	Status               string         `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	Icon                 string         `protobuf:"bytes,3,opt,name=icon,proto3" json:"icon,omitempty"`
	MetricName           string         `protobuf:"bytes,4,opt,name=metricName,proto3" json:"metricName,omitempty"`
	StartedAt            *v1.Time       `protobuf:"bytes,5,opt,name=startedAt,proto3" json:"startedAt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_JobInfo proto.InternalMessageInfo

func (m *JobInfo) GetObjectMeta() *v1.ObjectMeta {
	if m != nil {
		return m.ObjectMeta
	}
	return nil
}

func (m *JobInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *JobInfo) GetIcon() string {
	if m != nil {
		return m.Icon
	}
	return ""
}

func (m *JobInfo) GetMetricName() string {
	if m != nil {
		return m.MetricName
	}
	return ""
}

func (m *JobInfo) GetStartedAt() *v1.Time {
	if m != nil {
		return m.StartedAt
	}
	return nil
}

type AnalysisRunSpecAndStatus struct {
	Spec                 *v1alpha1.AnalysisRunSpec   `protobuf:"bytes,1,opt,name=spec,proto3" json:"spec,omitempty"`
	Status               *v1alpha1.AnalysisRunStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_AnalysisRunSpecAndStatus proto.InternalMessageInfo

func (m *AnalysisRunSpecAndStatus) GetSpec() *v1alpha1.AnalysisRunSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *AnalysisRunSpecAndStatus) GetStatus() *v1alpha1.AnalysisRunStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type AnalysisRunInfo struct {
	ObjectMeta *v1.ObjectMeta `protobuf:"bytes,1,opt,name=objectMeta,proto3" json:"objectMeta,omitempty"`
	//
	//field type from 161 -170 will be deprecated in future.
	Icon         string        `protobuf:"bytes,2,opt,name=icon,proto3" json:"icon,omitempty"`
	Revision     int64         `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
	Status       string        `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	Successful   int32         `protobuf:"varint,5,opt,name=successful,proto3" json:"successful,omitempty"`
	Failed       int32         `protobuf:"varint,6,opt,name=failed,proto3" json:"failed,omitempty"`
	Inconclusive int32         `protobuf:"varint,7,opt,name=inconclusive,proto3" json:"inconclusive,omitempty"`
	Error        int32         `protobuf:"varint,8,opt,name=error,proto3" json:"error,omitempty"`
	Jobs         []*JobInfo    `protobuf:"bytes,9,rep,name=jobs,proto3" json:"jobs,omitempty"`
	NonJobInfo   []*NonJobInfo `protobuf:"bytes,10,rep,name=nonJobInfo,proto3" json:"nonJobInfo,omitempty"`
	Metrics      []*Metrics    `protobuf:"bytes,11,rep,name=metrics,proto3" json:"metrics,omitempty"`
	// The new API changes should use SpecAndStatus field type.
	SpecAndStatus        *AnalysisRunSpecAndStatus `protobuf:"bytes,12,opt,name=specAndStatus,proto3" json:"specAndStatus,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_AnalysisRunInfo proto.InternalMessageInfo

func (m *AnalysisRunInfo) GetObjectMeta() *v1.ObjectMeta {
	if m != nil {
		return m.ObjectMeta
	}
	return nil
}

func (m *AnalysisRunInfo) GetIcon() string {
	if m != nil {
		return m.Icon
	}
	return ""
}

func (m *AnalysisRunInfo) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *AnalysisRunInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *AnalysisRunInfo) GetSuccessful() int32 {
	if m != nil {
		return m.Successful
	}
	return 0
}

func (m *AnalysisRunInfo) GetFailed() int32 {
	if m != nil {
		return m.Failed
	}
	return 0
}

func (m *AnalysisRunInfo) GetInconclusive() int32 {
	if m != nil {
		return m.Inconclusive
	}
	return 0
}

func (m *AnalysisRunInfo) GetError() int32 {
	if m != nil {
		return m.Error
	}
	return 0
}

func (m *AnalysisRunInfo) GetJobs() []*JobInfo {
	if m != nil {
		return m.Jobs
	}
	return nil
}

func (m *AnalysisRunInfo) GetNonJobInfo() []*NonJobInfo {
	if m != nil {
		return m.NonJobInfo
	}
	return nil
}

func (m *AnalysisRunInfo) GetMetrics() []*Metrics {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *AnalysisRunInfo) GetSpecAndStatus() *AnalysisRunSpecAndStatus {
	if m != nil {
		return m.SpecAndStatus
	}
	return nil
}

type NonJobInfo struct {
	Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Status               string   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	MetricName           string   `protobuf:"bytes,3,opt,name=metricName,proto3" json:"metricName,omitempty"`
	StartedAt            *v1.Time `protobuf:"bytes,4,opt,name=startedAt,proto3" json:"startedAt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NonJobInfo proto.InternalMessageInfo

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

func (m *NonJobInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *NonJobInfo) GetMetricName() string {
	if m != nil {
		return m.MetricName
	}
	return ""
}

func (m *NonJobInfo) GetStartedAt() *v1.Time {
	if m != nil {
		return m.StartedAt
	}
	return nil
}

type Metrics struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	SuccessCondition     string   `protobuf:"bytes,2,opt,name=successCondition,proto3" json:"successCondition,omitempty"`
	Count                int32    `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	InconclusiveLimit    int32    `protobuf:"varint,4,opt,name=inconclusiveLimit,proto3" json:"inconclusiveLimit,omitempty"`
	FailureLimit         int32    `protobuf:"varint,5,opt,name=failureLimit,proto3" json:"failureLimit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Metrics proto.InternalMessageInfo

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

func (m *Metrics) GetSuccessCondition() string {
	if m != nil {
		return m.SuccessCondition
	}
	return ""
}

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

func (m *Metrics) GetInconclusiveLimit() int32 {
	if m != nil {
		return m.InconclusiveLimit
	}
	return 0
}

func (m *Metrics) GetFailureLimit() int32 {
	if m != nil {
		return m.FailureLimit
	}
	return 0
}

func init() {
	proto.RegisterType((*RolloutInfoQuery)(nil), "rollout.RolloutInfoQuery")
	proto.RegisterType((*RolloutInfoListQuery)(nil), "rollout.RolloutInfoListQuery")
	proto.RegisterType((*SetImageRequest)(nil), "rollout.SetImageRequest")
	proto.RegisterType((*UndoRolloutRequest)(nil), "rollout.UndoRolloutRequest")
	proto.RegisterType((*RestartRolloutRequest)(nil), "rollout.RestartRolloutRequest")
	proto.RegisterType((*PromoteRolloutRequest)(nil), "rollout.PromoteRolloutRequest")
	proto.RegisterType((*AbortRolloutRequest)(nil), "rollout.AbortRolloutRequest")
	proto.RegisterType((*RetryRolloutRequest)(nil), "rollout.RetryRolloutRequest")
	proto.RegisterType((*RolloutWatchEvent)(nil), "rollout.RolloutWatchEvent")
	proto.RegisterType((*NamespaceInfo)(nil), "rollout.NamespaceInfo")
	proto.RegisterType((*RolloutInfoList)(nil), "rollout.RolloutInfoList")
	proto.RegisterType((*VersionInfo)(nil), "rollout.VersionInfo")
	proto.RegisterType((*RolloutInfo)(nil), "rollout.RolloutInfo")
	proto.RegisterType((*ExperimentInfo)(nil), "rollout.ExperimentInfo")
	proto.RegisterType((*ReplicaSetInfo)(nil), "rollout.ReplicaSetInfo")
	proto.RegisterType((*PodInfo)(nil), "rollout.PodInfo")
	proto.RegisterType((*ContainerInfo)(nil), "rollout.ContainerInfo")
	proto.RegisterType((*JobInfo)(nil), "rollout.JobInfo")
	proto.RegisterType((*AnalysisRunSpecAndStatus)(nil), "rollout.AnalysisRunSpecAndStatus")
	proto.RegisterType((*AnalysisRunInfo)(nil), "rollout.AnalysisRunInfo")
	proto.RegisterType((*NonJobInfo)(nil), "rollout.NonJobInfo")
	proto.RegisterType((*Metrics)(nil), "rollout.Metrics")
}

func init() {
	proto.RegisterFile("pkg/apiclient/rollout/rollout.proto", fileDescriptor_99101d942e8912a7)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// RolloutServiceClient is the client API for RolloutService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RolloutServiceClient interface {
	GetRolloutInfo(ctx context.Context, in *RolloutInfoQuery, opts ...grpc.CallOption) (*RolloutInfo, error)
	WatchRolloutInfo(ctx context.Context, in *RolloutInfoQuery, opts ...grpc.CallOption) (RolloutService_WatchRolloutInfoClient, error)
	ListRolloutInfos(ctx context.Context, in *RolloutInfoListQuery, opts ...grpc.CallOption) (*RolloutInfoList, error)
	WatchRolloutInfos(ctx context.Context, in *RolloutInfoListQuery, opts ...grpc.CallOption) (RolloutService_WatchRolloutInfosClient, error)
	GetNamespace(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NamespaceInfo, error)
	RestartRollout(ctx context.Context, in *RestartRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error)
	PromoteRollout(ctx context.Context, in *PromoteRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error)
	AbortRollout(ctx context.Context, in *AbortRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error)
	SetRolloutImage(ctx context.Context, in *SetImageRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error)
	UndoRollout(ctx context.Context, in *UndoRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error)
	RetryRollout(ctx context.Context, in *RetryRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error)
	Version(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*VersionInfo, error)
}

type rolloutServiceClient struct {
	cc *grpc.ClientConn
}

func NewRolloutServiceClient(cc *grpc.ClientConn) RolloutServiceClient {
	return &rolloutServiceClient{cc}
}

func (c *rolloutServiceClient) GetRolloutInfo(ctx context.Context, in *RolloutInfoQuery, opts ...grpc.CallOption) (*RolloutInfo, error) {
	out := new(RolloutInfo)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/GetRolloutInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) WatchRolloutInfo(ctx context.Context, in *RolloutInfoQuery, opts ...grpc.CallOption) (RolloutService_WatchRolloutInfoClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RolloutService_serviceDesc.Streams[0], "/rollout.RolloutService/WatchRolloutInfo", opts...)
	if err != nil {
		return nil, err
	}
	x := &rolloutServiceWatchRolloutInfoClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type RolloutService_WatchRolloutInfoClient interface {
	Recv() (*RolloutInfo, error)
	grpc.ClientStream
}

type rolloutServiceWatchRolloutInfoClient struct {
	grpc.ClientStream
}

func (x *rolloutServiceWatchRolloutInfoClient) Recv() (*RolloutInfo, error) {
	m := new(RolloutInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *rolloutServiceClient) ListRolloutInfos(ctx context.Context, in *RolloutInfoListQuery, opts ...grpc.CallOption) (*RolloutInfoList, error) {
	out := new(RolloutInfoList)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/ListRolloutInfos", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) WatchRolloutInfos(ctx context.Context, in *RolloutInfoListQuery, opts ...grpc.CallOption) (RolloutService_WatchRolloutInfosClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RolloutService_serviceDesc.Streams[1], "/rollout.RolloutService/WatchRolloutInfos", opts...)
	if err != nil {
		return nil, err
	}
	x := &rolloutServiceWatchRolloutInfosClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type RolloutService_WatchRolloutInfosClient interface {
	Recv() (*RolloutWatchEvent, error)
	grpc.ClientStream
}

type rolloutServiceWatchRolloutInfosClient struct {
	grpc.ClientStream
}

func (x *rolloutServiceWatchRolloutInfosClient) Recv() (*RolloutWatchEvent, error) {
	m := new(RolloutWatchEvent)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *rolloutServiceClient) GetNamespace(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NamespaceInfo, error) {
	out := new(NamespaceInfo)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/GetNamespace", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) RestartRollout(ctx context.Context, in *RestartRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error) {
	out := new(v1alpha1.Rollout)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/RestartRollout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) PromoteRollout(ctx context.Context, in *PromoteRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error) {
	out := new(v1alpha1.Rollout)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/PromoteRollout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) AbortRollout(ctx context.Context, in *AbortRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error) {
	out := new(v1alpha1.Rollout)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/AbortRollout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) SetRolloutImage(ctx context.Context, in *SetImageRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error) {
	out := new(v1alpha1.Rollout)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/SetRolloutImage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) UndoRollout(ctx context.Context, in *UndoRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error) {
	out := new(v1alpha1.Rollout)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/UndoRollout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) RetryRollout(ctx context.Context, in *RetryRolloutRequest, opts ...grpc.CallOption) (*v1alpha1.Rollout, error) {
	out := new(v1alpha1.Rollout)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/RetryRollout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rolloutServiceClient) Version(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*VersionInfo, error) {
	out := new(VersionInfo)
	err := c.cc.Invoke(ctx, "/rollout.RolloutService/Version", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RolloutServiceServer is the server API for RolloutService service.
type RolloutServiceServer interface {
	GetRolloutInfo(context.Context, *RolloutInfoQuery) (*RolloutInfo, error)
	WatchRolloutInfo(*RolloutInfoQuery, RolloutService_WatchRolloutInfoServer) error
	ListRolloutInfos(context.Context, *RolloutInfoListQuery) (*RolloutInfoList, error)
	WatchRolloutInfos(*RolloutInfoListQuery, RolloutService_WatchRolloutInfosServer) error
	GetNamespace(context.Context, *emptypb.Empty) (*NamespaceInfo, error)
	RestartRollout(context.Context, *RestartRolloutRequest) (*v1alpha1.Rollout, error)
	PromoteRollout(context.Context, *PromoteRolloutRequest) (*v1alpha1.Rollout, error)
	AbortRollout(context.Context, *AbortRolloutRequest) (*v1alpha1.Rollout, error)
	SetRolloutImage(context.Context, *SetImageRequest) (*v1alpha1.Rollout, error)
	UndoRollout(context.Context, *UndoRolloutRequest) (*v1alpha1.Rollout, error)
	RetryRollout(context.Context, *RetryRolloutRequest) (*v1alpha1.Rollout, error)
	Version(context.Context, *emptypb.Empty) (*VersionInfo, error)
}

// UnimplementedRolloutServiceServer can be embedded to have forward compatible implementations.
type UnimplementedRolloutServiceServer struct {
}

func (*UnimplementedRolloutServiceServer) GetRolloutInfo(ctx context.Context, req *RolloutInfoQuery) (*RolloutInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRolloutInfo not implemented")
}
func (*UnimplementedRolloutServiceServer) WatchRolloutInfo(req *RolloutInfoQuery, srv RolloutService_WatchRolloutInfoServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchRolloutInfo not implemented")
}
func (*UnimplementedRolloutServiceServer) ListRolloutInfos(ctx context.Context, req *RolloutInfoListQuery) (*RolloutInfoList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRolloutInfos not implemented")
}
func (*UnimplementedRolloutServiceServer) WatchRolloutInfos(req *RolloutInfoListQuery, srv RolloutService_WatchRolloutInfosServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchRolloutInfos not implemented")
}
func (*UnimplementedRolloutServiceServer) GetNamespace(ctx context.Context, req *emptypb.Empty) (*NamespaceInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNamespace not implemented")
}
func (*UnimplementedRolloutServiceServer) RestartRollout(ctx context.Context, req *RestartRolloutRequest) (*v1alpha1.Rollout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartRollout not implemented")
}
func (*UnimplementedRolloutServiceServer) PromoteRollout(ctx context.Context, req *PromoteRolloutRequest) (*v1alpha1.Rollout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PromoteRollout not implemented")
}
func (*UnimplementedRolloutServiceServer) AbortRollout(ctx context.Context, req *AbortRolloutRequest) (*v1alpha1.Rollout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AbortRollout not implemented")
}
func (*UnimplementedRolloutServiceServer) SetRolloutImage(ctx context.Context, req *SetImageRequest) (*v1alpha1.Rollout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetRolloutImage not implemented")
}
func (*UnimplementedRolloutServiceServer) UndoRollout(ctx context.Context, req *UndoRolloutRequest) (*v1alpha1.Rollout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UndoRollout not implemented")
}
func (*UnimplementedRolloutServiceServer) RetryRollout(ctx context.Context, req *RetryRolloutRequest) (*v1alpha1.Rollout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RetryRollout not implemented")
}
func (*UnimplementedRolloutServiceServer) Version(ctx context.Context, req *emptypb.Empty) (*VersionInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Version not implemented")
}

func RegisterRolloutServiceServer(s *grpc.Server, srv RolloutServiceServer) {
	s.RegisterService(&_RolloutService_serviceDesc, srv)
}

func _RolloutService_GetRolloutInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RolloutInfoQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).GetRolloutInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/GetRolloutInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).GetRolloutInfo(ctx, req.(*RolloutInfoQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_WatchRolloutInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RolloutInfoQuery)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RolloutServiceServer).WatchRolloutInfo(m, &rolloutServiceWatchRolloutInfoServer{stream})
}

type RolloutService_WatchRolloutInfoServer interface {
	Send(*RolloutInfo) error
	grpc.ServerStream
}

type rolloutServiceWatchRolloutInfoServer struct {
	grpc.ServerStream
}

func (x *rolloutServiceWatchRolloutInfoServer) Send(m *RolloutInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _RolloutService_ListRolloutInfos_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RolloutInfoListQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).ListRolloutInfos(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/ListRolloutInfos",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).ListRolloutInfos(ctx, req.(*RolloutInfoListQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_WatchRolloutInfos_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RolloutInfoListQuery)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RolloutServiceServer).WatchRolloutInfos(m, &rolloutServiceWatchRolloutInfosServer{stream})
}

type RolloutService_WatchRolloutInfosServer interface {
	Send(*RolloutWatchEvent) error
	grpc.ServerStream
}

type rolloutServiceWatchRolloutInfosServer struct {
	grpc.ServerStream
}

func (x *rolloutServiceWatchRolloutInfosServer) Send(m *RolloutWatchEvent) error {
	return x.ServerStream.SendMsg(m)
}

func _RolloutService_GetNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).GetNamespace(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/GetNamespace",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).GetNamespace(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_RestartRollout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestartRolloutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).RestartRollout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/RestartRollout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).RestartRollout(ctx, req.(*RestartRolloutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_PromoteRollout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PromoteRolloutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).PromoteRollout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/PromoteRollout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).PromoteRollout(ctx, req.(*PromoteRolloutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_AbortRollout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AbortRolloutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).AbortRollout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/AbortRollout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).AbortRollout(ctx, req.(*AbortRolloutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_SetRolloutImage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetImageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).SetRolloutImage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/SetRolloutImage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).SetRolloutImage(ctx, req.(*SetImageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_UndoRollout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UndoRolloutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).UndoRollout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/UndoRollout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).UndoRollout(ctx, req.(*UndoRolloutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_RetryRollout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RetryRolloutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).RetryRollout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/RetryRollout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).RetryRollout(ctx, req.(*RetryRolloutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RolloutService_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RolloutServiceServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rollout.RolloutService/Version",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RolloutServiceServer).Version(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _RolloutService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rollout.RolloutService",
	HandlerType: (*RolloutServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRolloutInfo",
			Handler:    _RolloutService_GetRolloutInfo_Handler,
		},
		{
			MethodName: "ListRolloutInfos",
			Handler:    _RolloutService_ListRolloutInfos_Handler,
		},
		{
			MethodName: "GetNamespace",
			Handler:    _RolloutService_GetNamespace_Handler,
		},
		{
			MethodName: "RestartRollout",
			Handler:    _RolloutService_RestartRollout_Handler,
		},
		{
			MethodName: "PromoteRollout",
			Handler:    _RolloutService_PromoteRollout_Handler,
		},
		{
			MethodName: "AbortRollout",
			Handler:    _RolloutService_AbortRollout_Handler,
		},
		{
			MethodName: "SetRolloutImage",
			Handler:    _RolloutService_SetRolloutImage_Handler,
		},
		{
			MethodName: "UndoRollout",
			Handler:    _RolloutService_UndoRollout_Handler,
		},
		{
			MethodName: "RetryRollout",
			Handler:    _RolloutService_RetryRollout_Handler,
		},
		{
			MethodName: "Version",
			Handler:    _RolloutService_Version_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchRolloutInfo",
			Handler:       _RolloutService_WatchRolloutInfo_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WatchRolloutInfos",
			Handler:       _RolloutService_WatchRolloutInfos_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pkg/apiclient/rollout/rollout.proto",
}

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

func (m *RolloutInfoQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RolloutInfoListQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SetImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Tag) > 0 {
		i -= len(m.Tag)
		copy(dAtA[i:], m.Tag)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Tag)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Image) > 0 {
		i -= len(m.Image)
		copy(dAtA[i:], m.Image)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Image)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Container) > 0 {
		i -= len(m.Container)
		copy(dAtA[i:], m.Container)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Container)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Rollout) > 0 {
		i -= len(m.Rollout)
		copy(dAtA[i:], m.Rollout)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Rollout)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UndoRolloutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Revision != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Rollout) > 0 {
		i -= len(m.Rollout)
		copy(dAtA[i:], m.Rollout)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Rollout)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RestartRolloutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PromoteRolloutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Full {
		i--
		if m.Full {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AbortRolloutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RetryRolloutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RolloutWatchEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RolloutInfo != nil {
		{
			size, err := m.RolloutInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NamespaceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.AvailableNamespaces) > 0 {
		for iNdEx := len(m.AvailableNamespaces) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.AvailableNamespaces[iNdEx])
			copy(dAtA[i:], m.AvailableNamespaces[iNdEx])
			i = encodeVarintRollout(dAtA, i, uint64(len(m.AvailableNamespaces[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *VersionInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.RolloutsVersion) > 0 {
		i -= len(m.RolloutsVersion)
		copy(dAtA[i:], m.RolloutsVersion)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.RolloutsVersion)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RolloutInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.InitContainers) > 0 {
		for iNdEx := len(m.InitContainers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InitContainers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	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 = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.Containers) > 0 {
		for iNdEx := len(m.Containers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Containers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	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 = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.Experiments) > 0 {
		for iNdEx := len(m.Experiments) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Experiments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.ReplicaSets) > 0 {
		for iNdEx := len(m.ReplicaSets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReplicaSets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.Generation) > 0 {
		i -= len(m.Generation)
		copy(dAtA[i:], m.Generation)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Generation)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.RestartedAt) > 0 {
		i -= len(m.RestartedAt)
		copy(dAtA[i:], m.RestartedAt)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.RestartedAt)))
		i--
		dAtA[i] = 0x72
	}
	if m.Available != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Available))
		i--
		dAtA[i] = 0x68
	}
	if m.Updated != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Updated))
		i--
		dAtA[i] = 0x60
	}
	if m.Desired != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Desired))
		i--
		dAtA[i] = 0x58
	}
	if m.Current != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Current))
		i--
		dAtA[i] = 0x50
	}
	if m.Ready != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Ready))
		i--
		dAtA[i] = 0x48
	}
	if len(m.ActualWeight) > 0 {
		i -= len(m.ActualWeight)
		copy(dAtA[i:], m.ActualWeight)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.ActualWeight)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.SetWeight) > 0 {
		i -= len(m.SetWeight)
		copy(dAtA[i:], m.SetWeight)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.SetWeight)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Step) > 0 {
		i -= len(m.Step)
		copy(dAtA[i:], m.Step)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Step)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Strategy) > 0 {
		i -= len(m.Strategy)
		copy(dAtA[i:], m.Strategy)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Strategy)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Icon) > 0 {
		i -= len(m.Icon)
		copy(dAtA[i:], m.Icon)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Icon)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x12
	}
	if m.ObjectMeta != nil {
		{
			size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ExperimentInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if 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 = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.ReplicaSets) > 0 {
		for iNdEx := len(m.ReplicaSets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReplicaSets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x22
	}
	if m.Revision != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Icon) > 0 {
		i -= len(m.Icon)
		copy(dAtA[i:], m.Icon)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Icon)))
		i--
		dAtA[i] = 0x12
	}
	if m.ObjectMeta != nil {
		{
			size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReplicaSetInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.InitContainerImages) > 0 {
		for iNdEx := len(m.InitContainerImages) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.InitContainerImages[iNdEx])
			copy(dAtA[i:], m.InitContainerImages[iNdEx])
			i = encodeVarintRollout(dAtA, i, uint64(len(m.InitContainerImages[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if m.Pong {
		i--
		if m.Pong {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.Ping {
		i--
		if m.Ping {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x78
	}
	if len(m.Pods) > 0 {
		for iNdEx := len(m.Pods) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Pods[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.Images) > 0 {
		for iNdEx := len(m.Images) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Images[iNdEx])
			copy(dAtA[i:], m.Images[iNdEx])
			i = encodeVarintRollout(dAtA, i, uint64(len(m.Images[iNdEx])))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.ScaleDownDeadline) > 0 {
		i -= len(m.ScaleDownDeadline)
		copy(dAtA[i:], m.ScaleDownDeadline)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.ScaleDownDeadline)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.Template) > 0 {
		i -= len(m.Template)
		copy(dAtA[i:], m.Template)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Template)))
		i--
		dAtA[i] = 0x5a
	}
	if m.Available != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Available))
		i--
		dAtA[i] = 0x50
	}
	if m.Replicas != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x48
	}
	if m.Preview {
		i--
		if m.Preview {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.Active {
		i--
		if m.Active {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Canary {
		i--
		if m.Canary {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Stable {
		i--
		if m.Stable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Revision != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Icon) > 0 {
		i -= len(m.Icon)
		copy(dAtA[i:], m.Icon)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Icon)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x12
	}
	if m.ObjectMeta != nil {
		{
			size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PodInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Restarts != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Restarts))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Ready) > 0 {
		i -= len(m.Ready)
		copy(dAtA[i:], m.Ready)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Ready)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Icon) > 0 {
		i -= len(m.Icon)
		copy(dAtA[i:], m.Icon)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Icon)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x12
	}
	if m.ObjectMeta != nil {
		{
			size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ContainerInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Image) > 0 {
		i -= len(m.Image)
		copy(dAtA[i:], m.Image)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Image)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *JobInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.StartedAt != nil {
		{
			size, err := m.StartedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.MetricName) > 0 {
		i -= len(m.MetricName)
		copy(dAtA[i:], m.MetricName)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.MetricName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Icon) > 0 {
		i -= len(m.Icon)
		copy(dAtA[i:], m.Icon)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Icon)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x12
	}
	if m.ObjectMeta != nil {
		{
			size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *AnalysisRunInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SpecAndStatus != nil {
		{
			size, err := m.SpecAndStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	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 = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NonJobInfo) > 0 {
		for iNdEx := len(m.NonJobInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonJobInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.Jobs) > 0 {
		for iNdEx := len(m.Jobs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Jobs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRollout(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.Error != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Error))
		i--
		dAtA[i] = 0x40
	}
	if m.Inconclusive != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Inconclusive))
		i--
		dAtA[i] = 0x38
	}
	if m.Failed != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Failed))
		i--
		dAtA[i] = 0x30
	}
	if m.Successful != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Successful))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x22
	}
	if m.Revision != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Icon) > 0 {
		i -= len(m.Icon)
		copy(dAtA[i:], m.Icon)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Icon)))
		i--
		dAtA[i] = 0x12
	}
	if m.ObjectMeta != nil {
		{
			size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NonJobInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.StartedAt != nil {
		{
			size, err := m.StartedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRollout(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.MetricName) > 0 {
		i -= len(m.MetricName)
		copy(dAtA[i:], m.MetricName)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.MetricName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Metrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FailureLimit != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.FailureLimit))
		i--
		dAtA[i] = 0x28
	}
	if m.InconclusiveLimit != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.InconclusiveLimit))
		i--
		dAtA[i] = 0x20
	}
	if m.Count != 0 {
		i = encodeVarintRollout(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x18
	}
	if len(m.SuccessCondition) > 0 {
		i -= len(m.SuccessCondition)
		copy(dAtA[i:], m.SuccessCondition)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.SuccessCondition)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRollout(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintRollout(dAtA []byte, offset int, v uint64) int {
	offset -= sovRollout(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RolloutInfoQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RolloutInfoListQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetImageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Rollout)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Container)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Image)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Tag)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UndoRolloutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Rollout)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRollout(uint64(m.Revision))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RestartRolloutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PromoteRolloutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Full {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AbortRolloutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RetryRolloutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RolloutWatchEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.RolloutInfo != nil {
		l = m.RolloutInfo.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NamespaceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if len(m.AvailableNamespaces) > 0 {
		for _, s := range m.AvailableNamespaces {
			l = len(s)
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RolloutInfoList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Rollouts) > 0 {
		for _, e := range m.Rollouts {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VersionInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RolloutsVersion)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RolloutInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectMeta != nil {
		l = m.ObjectMeta.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Icon)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Strategy)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Step)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.SetWeight)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.ActualWeight)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Ready != 0 {
		n += 1 + sovRollout(uint64(m.Ready))
	}
	if m.Current != 0 {
		n += 1 + sovRollout(uint64(m.Current))
	}
	if m.Desired != 0 {
		n += 1 + sovRollout(uint64(m.Desired))
	}
	if m.Updated != 0 {
		n += 1 + sovRollout(uint64(m.Updated))
	}
	if m.Available != 0 {
		n += 1 + sovRollout(uint64(m.Available))
	}
	l = len(m.RestartedAt)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Generation)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if len(m.ReplicaSets) > 0 {
		for _, e := range m.ReplicaSets {
			l = e.Size()
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if len(m.Experiments) > 0 {
		for _, e := range m.Experiments {
			l = e.Size()
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if len(m.AnalysisRuns) > 0 {
		for _, e := range m.AnalysisRuns {
			l = e.Size()
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if len(m.Containers) > 0 {
		for _, e := range m.Containers {
			l = e.Size()
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if len(m.Steps) > 0 {
		for _, e := range m.Steps {
			l = e.Size()
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if len(m.InitContainers) > 0 {
		for _, e := range m.InitContainers {
			l = e.Size()
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExperimentInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectMeta != nil {
		l = m.ObjectMeta.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Icon)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRollout(uint64(m.Revision))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if len(m.ReplicaSets) > 0 {
		for _, e := range m.ReplicaSets {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if len(m.AnalysisRuns) > 0 {
		for _, e := range m.AnalysisRuns {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReplicaSetInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectMeta != nil {
		l = m.ObjectMeta.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Icon)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRollout(uint64(m.Revision))
	}
	if m.Stable {
		n += 2
	}
	if m.Canary {
		n += 2
	}
	if m.Active {
		n += 2
	}
	if m.Preview {
		n += 2
	}
	if m.Replicas != 0 {
		n += 1 + sovRollout(uint64(m.Replicas))
	}
	if m.Available != 0 {
		n += 1 + sovRollout(uint64(m.Available))
	}
	l = len(m.Template)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.ScaleDownDeadline)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if len(m.Images) > 0 {
		for _, s := range m.Images {
			l = len(s)
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if len(m.Pods) > 0 {
		for _, e := range m.Pods {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if m.Ping {
		n += 2
	}
	if m.Pong {
		n += 3
	}
	if len(m.InitContainerImages) > 0 {
		for _, s := range m.InitContainerImages {
			l = len(s)
			n += 2 + l + sovRollout(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PodInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectMeta != nil {
		l = m.ObjectMeta.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Icon)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Ready)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Restarts != 0 {
		n += 1 + sovRollout(uint64(m.Restarts))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ContainerInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Image)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *JobInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectMeta != nil {
		l = m.ObjectMeta.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Icon)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.MetricName)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.StartedAt != nil {
		l = m.StartedAt.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AnalysisRunSpecAndStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AnalysisRunInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectMeta != nil {
		l = m.ObjectMeta.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Icon)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRollout(uint64(m.Revision))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Successful != 0 {
		n += 1 + sovRollout(uint64(m.Successful))
	}
	if m.Failed != 0 {
		n += 1 + sovRollout(uint64(m.Failed))
	}
	if m.Inconclusive != 0 {
		n += 1 + sovRollout(uint64(m.Inconclusive))
	}
	if m.Error != 0 {
		n += 1 + sovRollout(uint64(m.Error))
	}
	if len(m.Jobs) > 0 {
		for _, e := range m.Jobs {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if len(m.NonJobInfo) > 0 {
		for _, e := range m.NonJobInfo {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if len(m.Metrics) > 0 {
		for _, e := range m.Metrics {
			l = e.Size()
			n += 1 + l + sovRollout(uint64(l))
		}
	}
	if m.SpecAndStatus != nil {
		l = m.SpecAndStatus.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NonJobInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.MetricName)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.StartedAt != nil {
		l = m.StartedAt.Size()
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Metrics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	l = len(m.SuccessCondition)
	if l > 0 {
		n += 1 + l + sovRollout(uint64(l))
	}
	if m.Count != 0 {
		n += 1 + sovRollout(uint64(m.Count))
	}
	if m.InconclusiveLimit != 0 {
		n += 1 + sovRollout(uint64(m.InconclusiveLimit))
	}
	if m.FailureLimit != 0 {
		n += 1 + sovRollout(uint64(m.FailureLimit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovRollout(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRollout(x uint64) (n int) {
	return sovRollout(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RolloutInfoQuery) 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 ErrIntOverflowRollout
			}
			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: RolloutInfoQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutInfoQuery: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RolloutInfoListQuery) 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 ErrIntOverflowRollout
			}
			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: RolloutInfoListQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutInfoListQuery: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetImageRequest) 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 ErrIntOverflowRollout
			}
			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: SetImageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetImageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rollout", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Rollout = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Container = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Image = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RestartRolloutRequest) 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 ErrIntOverflowRollout
			}
			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: RestartRolloutRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RestartRolloutRequest: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PromoteRolloutRequest) 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 ErrIntOverflowRollout
			}
			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: PromoteRolloutRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PromoteRolloutRequest: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Full", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Full = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AbortRolloutRequest) 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 ErrIntOverflowRollout
			}
			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: AbortRolloutRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AbortRolloutRequest: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RetryRolloutRequest) 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 ErrIntOverflowRollout
			}
			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: RetryRolloutRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RetryRolloutRequest: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RolloutWatchEvent) 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 ErrIntOverflowRollout
			}
			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: RolloutWatchEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutWatchEvent: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RolloutInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RolloutInfo == nil {
				m.RolloutInfo = &RolloutInfo{}
			}
			if err := m.RolloutInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RolloutInfo) 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 ErrIntOverflowRollout
			}
			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: RolloutInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolloutInfo: 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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectMeta == nil {
				m.ObjectMeta = &v1.ObjectMeta{}
			}
			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 Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Strategy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Step = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SetWeight = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActualWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActualWeight = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ready", wireType)
			}
			m.Ready = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ready |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType)
			}
			m.Current = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Current |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desired", wireType)
			}
			m.Desired = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Desired |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updated", wireType)
			}
			m.Updated = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Updated |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType)
			}
			m.Available = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Available |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartedAt", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RestartedAt = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Generation = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaSets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplicaSets = append(m.ReplicaSets, &ReplicaSetInfo{})
			if err := m.ReplicaSets[len(m.ReplicaSets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Experiments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Experiments = append(m.Experiments, &ExperimentInfo{})
			if err := m.Experiments[len(m.Experiments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AnalysisRuns = append(m.AnalysisRuns, &AnalysisRunInfo{})
			if err := m.AnalysisRuns[len(m.AnalysisRuns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Containers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Containers = append(m.Containers, &ContainerInfo{})
			if err := m.Containers[len(m.Containers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Steps = append(m.Steps, &v1alpha1.CanaryStep{})
			if err := m.Steps[len(m.Steps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitContainers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitContainers = append(m.InitContainers, &ContainerInfo{})
			if err := m.InitContainers[len(m.InitContainers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExperimentInfo) 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 ErrIntOverflowRollout
			}
			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: ExperimentInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentInfo: 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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectMeta == nil {
				m.ObjectMeta = &v1.ObjectMeta{}
			}
			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 Icon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 ReplicaSets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplicaSets = append(m.ReplicaSets, &ReplicaSetInfo{})
			if err := m.ReplicaSets[len(m.ReplicaSets)-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 AnalysisRuns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AnalysisRuns = append(m.AnalysisRuns, &AnalysisRunInfo{})
			if err := m.AnalysisRuns[len(m.AnalysisRuns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaSetInfo) 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 ErrIntOverflowRollout
			}
			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: ReplicaSetInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaSetInfo: 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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectMeta == nil {
				m.ObjectMeta = &v1.ObjectMeta{}
			}
			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 Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Stable = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Canary", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Canary = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Active = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Preview", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Preview = bool(v != 0)
		case 9:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType)
			}
			m.Available = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Available |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Template = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDeadline", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScaleDownDeadline = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Images", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Images = append(m.Images, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pods = append(m.Pods, &PodInfo{})
			if err := m.Pods[len(m.Pods)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ping", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Ping = bool(v != 0)
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pong", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Pong = bool(v != 0)
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitContainerImages", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitContainerImages = append(m.InitContainerImages, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodInfo) 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 ErrIntOverflowRollout
			}
			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: PodInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodInfo: 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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectMeta == nil {
				m.ObjectMeta = &v1.ObjectMeta{}
			}
			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 Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ready", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ready = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Restarts", wireType)
			}
			m.Restarts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Restarts |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainerInfo) 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 ErrIntOverflowRollout
			}
			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: ContainerInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainerInfo: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 Image", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Image = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobInfo) 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 ErrIntOverflowRollout
			}
			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: JobInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobInfo: 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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectMeta == nil {
				m.ObjectMeta = &v1.ObjectMeta{}
			}
			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 Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisRunSpecAndStatus) 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 ErrIntOverflowRollout
			}
			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: AnalysisRunSpecAndStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunSpecAndStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &v1alpha1.AnalysisRunSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &v1alpha1.AnalysisRunStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalysisRunInfo) 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 ErrIntOverflowRollout
			}
			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: AnalysisRunInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalysisRunInfo: 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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectMeta == nil {
				m.ObjectMeta = &v1.ObjectMeta{}
			}
			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 Icon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Successful |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Failed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Inconclusive |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Error |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jobs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Jobs = append(m.Jobs, &JobInfo{})
			if err := m.Jobs[len(m.Jobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonJobInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonJobInfo = append(m.NonJobInfo, &NonJobInfo{})
			if err := m.NonJobInfo[len(m.NonJobInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metrics = append(m.Metrics, &Metrics{})
			if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpecAndStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SpecAndStatus == nil {
				m.SpecAndStatus = &AnalysisRunSpecAndStatus{}
			}
			if err := m.SpecAndStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NonJobInfo) 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 ErrIntOverflowRollout
			}
			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: NonJobInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NonJobInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricName = string(dAtA[iNdEx:postIndex])
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRollout
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Metrics) 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 ErrIntOverflowRollout
			}
			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: Metrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metrics: 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 ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			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 SuccessCondition", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				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 ErrInvalidLengthRollout
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRollout
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SuccessCondition = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InconclusiveLimit", wireType)
			}
			m.InconclusiveLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InconclusiveLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailureLimit", wireType)
			}
			m.FailureLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRollout
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FailureLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRollout(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRollout
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRollout(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, ErrIntOverflowRollout
			}
			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, ErrIntOverflowRollout
				}
				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, ErrIntOverflowRollout
				}
				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, ErrInvalidLengthRollout
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupRollout
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthRollout
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthRollout        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRollout          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRollout = fmt.Errorf("proto: unexpected end of group")
)
