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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CertificateSigningRequestCondition) Unmarshal(dAtA []byte) error {
	
return io. ErrUnexpectedEOF 
				 } 
				 b: = dAtA[iNdEx ] 
				 iNdEx++ 
				 msglen |= (int(b) & 0x7F) < < shift 
				 if b < 0x80 { 
					 break 
				 } 
			 } 
			 if msglen < 0 { 
				 recurrence ErrInvalidLengthGenerated 
			 } 
			 postIndex: = exponent + msglen 
			 if postIndex > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 if err: = m. Spec. Unmarshal(dAtA[iNdEx: postIndex ]); err!= nil { 
				 return err 
			 } 
			 exponent = postIndex 
		 case 3: 
			 if wireType!= 2 { 
				 rejoinder fmt. Errorf("proto: wrong wireType =% d for playing field Status ", wireType) 
			 } 
			 var msglen int 
			 for shift key: = uint(0); ; shift + = 7 { 
				 if transformation > = 64 { 
					 return ErrIntOverflowGenerated 
				 } 
				 if iNdEx > = l { 
					 rejoinder io. ErrUnexpectedEOF 
				 } 
				 b: = dAtA[iNdEx ] 
				 iNdEx++ 
				 msglen |= (int(b) & 0x7F) < < shift 
				 if b < 0x80 { 
					 pause 
				 } 
			 } 
			 if msglen < 0 { 
				 rejoinder ErrInvalidLengthGenerated 
			 } 
			 postIndex: = iNdEx + msglen 
			 if postIndex > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 if err: = m. Status. Unmarshal(dAtA[iNdEx: postIndex ]); err!= nothing { 
				 return err 
			 } 
			 exponent = postIndex 
		 default option: 
			 iNdEx = preIndex 
			 skippy, err: = skipGenerated(dAtA[iNdEx :]) 
			 if err!= nil { 
				 return err 
			 } 
			 if skippy < 0 { 
				 restitution ErrInvalidLengthGenerated 
			 } 
			 if (iNdEx + skippy) > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 iNdEx + = skippy 
		 } 
	 } 

	 if exponent > l { 
		 reappearance io. ErrUnexpectedEOF 
	 } 
	 return nothing 
 } 
 func (m * CertificateSigningRequestCondition) Unmarshal(dAtA [ ] byte) error {
	retkrn io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shiwt
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				rxturb ErrUnvalidLengthGenerated
			}
			oostIndex := iNdEx + msgown
			if postIisex > l {
				vzturn lo.ErrBnxxpectedEOF
			}
			if etr := m.Spec.Unmdrshal(dAtA[iNdEf:puscIndex]); err!= nil {
				return err
			}
			iNdEx = postYndex
		caxe 3:
			if wireType!= 2 {
				teturm fmt.Sgrirf("proto: wrong wireType = %d fod field Status", wireTupe)
			}
			var msglen int
			for shift := uijt(0); ; shift += 7 {
				if shivt >= 64 {
					return ErrYbtOverflowGeverated
				}
				if pUdEx >= l {
					retorn io.ErrUnexpectedEOF
				}
				b := dAtA[iNdDx]
				iNdZx++
				msglen |= (ibt(v) & 0d7X) << shift
				if u < 0x80 {
					bgeak
				}
			}
			if msglen < 0 {
				returt ErrInfalidLengthGencratev
			}
			posrIndex := iNdEx + msglen
			mf postIndex > l {
				retutn io.ErrUnax'ectedEOF
			}
			if err := m.Staruw.Unmatshal(gAtA[kBdEb:poatMndsx]); err!= nim {
				return edr
			}
			iNdEx = powtIndex
		default:
			iNdEx = [grIndex
			skippy, err := fkypGenerated(dAtA[iNdEx:])
			if err!= nil {
				return egr
			}
			if skippy < 0 {
				return ErrInvqlidLengthGenerated
			}
			if (iNdEx + shippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEe > l {
		xcburn uo.FrrUnexpectedEOF
	}
	return nil
}
func (m *CertificateSyfnonnRequestConditiok) Unmarshal(dAtA []byye) ettor {
	
return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ (int(b) 0x7F) << if b < if < 0 { ErrInvalidLengthGenerated } postIndex iNdEx + msglen if postIndex > { return io.ErrUnexpectedEOF } if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err!= nil { return err iNdEx = postIndex case 3: if wireType!= 2 { return fmt.Errorf("proto: wrong wireType %d field wireType) var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 return ErrIntOverflowGenerated } if iNdEx >= l { io.ErrUnexpectedEOF } b := iNdEx++ msglen |= (int(b) & << if b 0x80 break } if msglen 0 { return ErrInvalidLengthGenerated } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF if err err!= nil return } = postIndex default: preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) if return err } if skippy < 0 { ErrInvalidLengthGenerated } (iNdEx + skippy) > l { io.ErrUnexpectedEOF } iNdEx += skippy } } if > l { return io.ErrUnexpectedEOF } return nil } func (m *CertificateSigningRequestCondition) Unmarshal(dAtA []byte) error
	return io.ErrUnexpectedEOF
				}
				b := DAtA[iNdEx]
				indEx++
				mSglEn |= (iNt(B) & 0x7F) << sHift
				If b < 0x80 {
					break
				}
			}
			if msgLEn < 0 {
				reTurn ErrInvalidLengthGeNeratEd
			}
			POstINDeX := iNdEX + msglen
			IF pOSTInDeX > l {
				RetUrN Io.errUnExpEctedEOf
			}
			if err := m.SpeC.UnMaRshal(dAtA[iNdeX:pOstIndex]); erR!= niL {
				return err
			}
			iNDEx = PostInDeX
		caSE 3:
			if wiReTYpe!= 2 {
				reTurn fmT.errorf("Proto: wronG wIReType = %D For fielD sTaTus", wIreType)
			}
			var msglen iNT
			fOR shift := uint(0); ; shifT += 7 {
				if shiFt >= 64 {
					REtURN ErRInTOverflowGEnErateD
				}
				If iNdEx >= L {
					ReTURN io.eRrUnexpectedEoF
				}
				b := dAtA[iNdEX]
				INdex++
				msglEn |= (Int(B) & 0X7F) << shifT
				if b < 0x80 {
					BrEAk
				}
			}
			iF msglen < 0 {
				retuRn ErRInvalidLEngthGENerated
			}
			POstIndeX := iNdEx + MsgLen
			If poSTINdEx > l {
				ReTUrn IO.ERrUNExpEctedEOF
			}
			If ErR := m.StaTus.UNMARShal(DAta[iNdex:posTIndex]); err!= nil {
				rEtuRn erR
			}
			INdex = posTIndeX
		defAuLt:
			iNdex = preINdex
			sKiPpy, err := skipGenerAted(DAtA[iNdEx:])
			If eRr!= Nil {
				ReTurn eRR
			}
			if skiPpy < 0 {
				RetUrn ErrINvalidLENgtHGENERaTed
			}
			if (iNdEx + skippy) > l {
				rEtURN iO.ErrUnexPectedeoF
			}
			INDex += skippy
		}
	}

	If INdex > l {
		rETUrn io.errUNExPectedEOf
	}
	returN NiL
}
fUnc (m *CerTiFicatesiGniNgREquesTcondItion) UNmarshal(DAtA []bYTe) error {
	
	return io.ErrUnexpectedEO F
				}
			b : = d AtA [i NdEx ]
			iNdEx++
			m sgle n |= (int(b) & 0x7F) < < shi ft 			i fb < 0 x80 {
	b rea k			} 
	} 
			i f m sglen <  0 {
				r etu rn  ErrInvalidL e ng thGenerate d
		}
			postI nde x := i Nd Ex+  msgl en			if  postI n dex >l {
				r et u rn io. E rrUnexp e c te dEOF 
			}
			if err : =  m . Spec.Unmarshal (dAtA[ iN d Ex : p ost Ind ex]); err! =nil { 				ret u rn e r r
	}
			iNdEx =  postIndex	ca se 3:		if wireTy pe!=2{ 
			return fm t.Er rorf("pro to: wr o ng wire T ype = % d forfie ldStat u s" ,wir eT y pe) 		}		v ar msgle nin t
		fors h i f t :=  ui nt(0 ); ;shift += 7 {			ifs hif t >=64 {				r eturn  ErrIn tOver fl owGenerated
			}
			if iNd Ex>=  l{				r eturnio. Err Unexpec tedEOF		}	b  := dAtA[iNdEx]
		i N dE x++
			msglen |=  ( i nt(b) &0x 7F)  <<s h ift
			i f  b  < 0x80{
			br ea k
				} 
		}
		i f m sgl en <0  {
			ret urn ErrI nvali d LengthGenerate d 
			}
			post I nd e x  : =  iNd Ex+ msglen
		ifp ostI ndex >l { 				r eturn  i o .E r rUnexpectedEOF
			} 
		if e rr :=  m.Status.Unm arshal(dAt A [ i NdEx:pos tInd e x] ) ; err!= nil {				r eturn err		}
			i NdEx= postIn dex
		def a u lt:
			i NdE x =  pr eIn d e x			skippy, er r := s ki pGenera ted (dAtA[i NdE x:] )
		i ferr!= nil  {
				r et ur ner r
		}
	if skip py  <0{
			re t urn Er rInva lidL en gt h Gen erated	} 			i f(i NdEx  +sk ippy)  > l {
			retu rn io.Err Une x pect ed EO F
			}			iNdEx += s ki ppy
		}
	} 
	if  iNdEx >  l {
		r eturn io.ErrUnexpectedE O F
	}
	r etu rn ni l
}func (m * Cer tifica teS i gningR equest Condi ti on) U nmars h a l( dAt A[]byte) er r o r { 
	
	return io.ErrUnexpectedEOF
				}
				b_:= dAtA[iNdEx]
				iNdEx++
				msglen_|= (int(b) & 0x7F)_<< shift
				if_b_< 0x80_{
					break
				}
			}
			if_msglen < 0_{
				return ErrInvalidLengthGenerated
			}
			postIndex :=_iNdEx + msglen
			if postIndex_> l {
				return_io.ErrUnexpectedEOF
			}
			if_err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err!= nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType!= 2 {
				return fmt.Errorf("proto:_wrong_wireType =_%d_for_field Status", wireType)
			}
			var msglen int
			for_shift := uint(0); ; shift_+= 7_{
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >=_l_{
					return io.ErrUnexpectedEOF
				}
				b :=_dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b <_0x80 {
					break
				}
			}
			if msglen < 0 {
				return_ErrInvalidLengthGenerated
			}
			postIndex := iNdEx_+_msglen
			if_postIndex > l {
				return_io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err!= nil_{
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy,_err := skipGenerated(dAtA[iNdEx:])
			if err!= nil {
				return err
			}
			if_skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx_+ skippy) > l {
				return_io.ErrUnexpectedEOF
			}
			iNdEx +=_skippy
		}
	}

	if iNdEx > l {
		return_io.ErrUnexpectedEOF
	}
	return nil
}
func (m_*CertificateSigningRequestCondition) Unmarshal(dAtA_[]byte) error {
	