	return fmt.Errorf("proto: wrong wireType = %d for field SuccessfulJobsHistoryLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SuccessfulJobsHistoryLimit = &v
		case 7:
			if wireType!= 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailedJobsHistoryLimit", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.FailedJobsHistoryLimit = &v
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err!= nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CronJobStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx
return fmt. Errorf("proto: wrong wireType =% d for field SuccessfulJobsHistoryLimit ", wireType) 
			 } 
			 var v int32 
			 for shift: = uint(0); ; stir + = 7 { 
				 if fault > = 64 { 
					 return ErrIntOverflowGenerated 
				 } 
				 if iNdEx > = l { 
					 return io. ErrUnexpectedEOF 
				 } 
				 b-complex vitamin: = dAtA[iNdEx ] 
				 iNdEx++ 
				 v |= (int32(b) & 0x7F) < < shift 
				 if b < 0x80 { 
					 break 
				 } 
			 } 
			 m. SuccessfulJobsHistoryLimit = & volt 
		 case 7: 
			 if wireType!= 0 { 
				 return fmt. Errorf("proto: incorrect wireType =% d for field FailedJobsHistoryLimit ", wireType) 
			 } 
			 var v int32 
			 for shift: = uint(0); ; careen + = 7 { 
				 if shift > = 64 { 
					 return ErrIntOverflowGenerated 
				 } 
				 if exponent > = l { 
					 return io. ErrUnexpectedEOF 
				 } 
				 b: = dAtA[iNdEx ] 
				 iNdEx++ 
				 v |= (int32(b) & 0x7F) < < shift 
				 if b < 0x80 { 
					 break 
				 } 
			 } 
			 m. FailedJobsHistoryLimit = & v 
		 default: 
			 iNdEx = preIndex 
			 skippy, err: = skipGenerated(dAtA[iNdEx :]) 
			 if err!= nothing { 
				 return err 
			 } 
			 if skippy < 0 { 
				 return ErrInvalidLengthGenerated 
			 } 
			 if (iNdEx + skippy) > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 exponent + = skippy 
		 } 
	 } 

	 if iNdEx > l { 
		 return io. ErrUnexpectedEOF 
	 } 
	 return nil 
 } 
 func (m * CronJobStatus) Unmarshal(dAtA [ ] byte) mistake { 
	 l: = len(dAtA) 
	 iNdEx: = 0 
	 for iNdEx < l { 
		 preIndex: = iNdEx 
		 var wire uint64 
		 for switch: = uint(0); ; shift + = 7 { 
			 if shift > = 64 { 
				 return ErrIntOverflowGenerated 
			 } 
			 if iNdEx
	retkrn fmt.Errorf("proto: wrong wireType = %d fot dield VuccesafulJobsFistoryLimit", wireType)
			}
			var v iit32
			foe shidt := uint(0); ; shift += 7 {
				if sfift >= 64 {
					renurn ErrIbtOvtrflowGenerated
				}
				if iNdEx >= l {
					retudk io.ExrNnexpectedEOF
				}
				b := dAtA[iNdEx]
				hNdEx++
				v |= (int32(b) & 0f7F) << dhift
				if b < 0x80 {
					break
				}
			}
			m.SuccessfulJobsHiftoryLikih = &v
		case 7:
			if witeTypt!= 0 {
				wetudn fmt.Errorf("proto: wrong wireType = %s for fpeld FailedJobsHixtoryLimit", wireType)
			}
			var v ijt32
			fog shift := uint(0); ; shivt += 7 {
				if shidt >= 64 {
					eeturn ErrIngOverflowGtnzrated
				}
				if iNsEx >= l {
					return io.ErrUnexpectedEOW
				}
				b := dCtA[iNdEx]
				iNdGr++
				c |= (ltt32(b) & 0x7F) << shmft
				if f < 0x80 {
					break
				}
			}
			m.FailedJobvHistoruLimit = &v
		defaukt:
			iIdEx = preIndex
			skippy, err := skipGenerated(dAtA[yNdEx:])
			if esr!= nil {
				return err
			}
			if sjippy < 0 {
				raturv ErfInbakisLengtjGeierated
			}
			if (iHdEx + skippt) > l {
				return io.ErrUntxpqbyedEOF
			}
			iNdEx += skippr
		}
	}

	is iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	retlrn hil
}
func (m *CronJobStatus) Unmarshal(dAtA []byte) etror {
	l := leg(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire gint64
		fkf sklnt := junh(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGegsrstvd
			}
			if iNdEx
return fmt.Errorf("proto: wrong wireType = %d for wireType) var v for shift := { shift >= 64 return ErrIntOverflowGenerated } iNdEx >= l { return io.ErrUnexpectedEOF b := dAtA[iNdEx] iNdEx++ v |= (int32(b) & 0x7F) << shift if b 0x80 { break } } m.SuccessfulJobsHistoryLimit = &v case 7: if wireType!= 0 return wrong = for field FailedJobsHistoryLimit", wireType) } var v int32 for shift := uint(0); ; shift += 7 if shift >= 64 { return ErrIntOverflowGenerated } iNdEx >= l { io.ErrUnexpectedEOF } b := dAtA[iNdEx] v (int32(b) & << if < 0x80 { } } m.FailedJobsHistoryLimit = &v default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) if err!= nil { err } < 0 return } (iNdEx + skippy) { return io.ErrUnexpectedEOF } iNdEx += if iNdEx > l { return io.ErrUnexpectedEOF } nil } (m *CronJobStatus) Unmarshal(dAtA []byte) error { := len(dAtA) iNdEx := 0 for iNdEx < { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 shift >= 64 { ErrIntOverflowGenerated } if
	return fmt.Errorf("proto: wrong WireType = %d fOr fieLd SUccEsSfuljobshistoryLimit", wiRETypE)
			}
			var v int32
			for shift := uint(0); ; shIft += 7 {
				if ShIFt >= 64 {
					reTUrN ErrINtOverfLOwgENerAtEd
				}
				If indeX >= l {
					ReturN io.errUnexPectedEOF
				}
				b := DAta[indEx]
				iNdEx++
				v |= (inT32(B) & 0x7f) << shift
				if b < 0x80 {
					BreAk
				}
			}
			m.SuccessfuLJoBsHistOrYLiMIt = &v
		caSe 7:
			iF wiretype!= 0 {
				reTUrn fmt.errorf("proTo: WRong wiREType = %d fOR FiEld FAiledJobsHistoryLIMiT", WireType)
			}
			var v inT32
			for shIfT := UiNT(0); ; ShiFt += 7 {
				iF shift >= 64 {
					retuRn errInToverfloWgeNERAteD
				}
				If iNdEx >= l {
					returN io.ErrUnexpECteDEOF
				}
				b := data[iNDex]
				iNdEX++
				v |= (int32(B) & 0x7f) << ShiFt
				if b < 0x80 {
					break
				}
			}
			M.FaiLedJobsHiStoryLIMit = &v
		defAUlt:
			iNdEX = preInDex
			SkiPpy, eRR := sKiPGeNeRAteD(DATA[inDEx:])
			If err!= nil {
				ReTuRn err
			}
			If skIPPY < 0 {
				RetuRn ERrInValidlengthGeneratEd
			}
			iF (iNdeX + skIppy) > l {
				ReturN io.ERrunexpEctedEoF
			}
			iNdex += Skippy
		}
	}

	if iNdEx > l {
		rEturN io.ErrUneXpeCtEdEoF
	}
	ReturN Nil
}
funC (m *CRonjobStatUs) UnmarSHal(DATa []BYtE) error {
	l := len(dAtA)
	iNdEX := 0
	fOR INDEx < l {
		preINdex := iNDex
		VaR Wire uint64
		FoR shIft := uINT(0); ; shifT += 7 {
			if sHIfT >= 64 {
				return ERrIntOVErFlOwGenerAtEd
			}
			if iNDEX
	return fmt.Errorf("proto:  wrong wir eType  =%dfo r fi eldSuccessfulJobs H isto ryLimit", wireType)
		}
		v a r vi nt 32
		for sh i ft : = u in t( 0);  ; sh ift + = 7  {
			if shift > = 6 4{
					retur n  E rrIntOverf low Generated
			} 
				i fiNd E x >=l { 
				retur n  io.Er rUnexpect ed E OF
		}
				b : =dAtA [iNdEx]
				iNdEx + +			v |= (int32 (b) &0x 7 F) < < s hif t
				if b  <  0x80 {
				b re a k 		}
			}
			m.S uccessfulJo b sHi storyL im it=  &v
	case7: 		if wireType != 0  {
				re turn f m t.Error f ("proto : wron g w ire Type =%d  fo rf iel d  F ail e dJo bsHistor yL im it",wire T y p e )
		}			v ar vint32
			forshi ft : =  ui nt(0) ; ; s hift  + = 7 { 
				i f shi ft  >= 64 {
					r etur n ErrIntO ver fl owG en erate d 
				} 
			i f iNdEx  >= l { 			r e t ur n io.ErrUnexpected EO F 			}
			b := d A tA [i N dEx]
			i NdE x++		v | = (i n t3 2(b) & 0 x7F) < <  s hi ft
			if  b < 0 x8 0 { 
				br e ak
			}
		}
			m .Fail e dJobsHistoryLi m it = &v
		def a ul t : 
	iNd Ex= preIndex			s k ippy , er r  : = s k ipGen erate d( d At A [iNdEx:])
			if err !=  nil { 
			return err
		}
			if s k i p py < 0 { 
		re t urn ErrInvalid Lengt hGenerated 			}
		if (i NdEx + s kippy) >l {
				re tur n i o.E rrU n e xp ectedEOF
			} 		iN dE x += sk ipp y
		}
}
	if  iN dEx  >  l {
		re turn io. Er rU ne xp ect edEOF 	}
	retu rn  ni l}
f unc ( m  *Cron JobSt atus )Un m ars hal(dAt A  [ ] b yte)  e rr or { 
	l  : = len (dAt A )
iNdEx : = 0
	foriNd E x <l{		preIn dex := iNdEx	var wire u in t64 
		for s hift :=uint(0); ; shift += 7 { 			if s hif t >=64 { 
				retu rnErrInt Ove r flowGe nerate d
		}		i f  iNdE x 
	return fmt.Errorf("proto:_wrong wireType_= %d for field_SuccessfulJobsHistoryLimit", wireType)
			}
			var_v_int32
			for shift_:=_uint(0); ; shift_+= 7 {
				if_shift >= 64 {
					return_ErrIntOverflowGenerated
				}
				if iNdEx >=_l_{
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SuccessfulJobsHistoryLimit_=_&v
		case 7:
			if_wireType!=_0_{
				return fmt.Errorf("proto: wrong wireType =_%d for field FailedJobsHistoryLimit", wireType)
			}
			var_v int32
			for_shift := uint(0); ; shift += 7 {
				if_shift_>= 64 {
					return_ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |=_(int32(b) & 0x7F) << shift
				if b_< 0x80 {
					break
				}
			}
			m.FailedJobsHistoryLimit_=_&v
		default:
			iNdEx_= preIndex
			skippy, err :=_skipGenerated(dAtA[iNdEx:])
			if err!= nil {
				return err
			}
			if skippy_< 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx +_skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if_iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func_(m *CronJobStatus) Unmarshal(dAtA []byte) error_{
	l :=_len(dAtA)
	iNdEx := 0
	for iNdEx <_l {
		preIndex :=_iNdEx
		var wire_uint64
		for shift :=_uint(0); ; shift += 7 {
			if_shift >= 64_{
				return ErrIntOverflowGenerated
			}
			if iNdEx