cmd/bpa-operator/vendor/k8s.io/api/certificates/v1beta1/generated.pb.go

   1 /*
   2 Copyright The Kubernetes Authors.
   3
   4 Licensed under the Apache License, Version 2.0 (the "License");
   5 you may not use this file except in compliance with the License.
   6 You may obtain a copy of the License at
   7
   8     http://www.apache.org/licenses/LICENSE-2.0
   9
  10 Unless required by applicable law or agreed to in writing, software
  11 distributed under the License is distributed on an "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 See the License for the specific language governing permissions and
  14 limitations under the License.
  15 */
  16
  17 // Code generated by protoc-gen-gogo. DO NOT EDIT.
  18 // source: k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto
  19
  20 /*
  21         Package v1beta1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 CertificateSigningRequest
  28                 CertificateSigningRequestCondition
  29                 CertificateSigningRequestList
  30                 CertificateSigningRequestSpec
  31                 CertificateSigningRequestStatus
  32                 ExtraValue
  33 */
  34 package v1beta1
  35
  36 import proto "github.com/gogo/protobuf/proto"
  37 import fmt "fmt"
  38 import math "math"
  39
  40 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  41
  42 import strings "strings"
  43 import reflect "reflect"
  44
  45 import io "io"
  46
  47 // Reference imports to suppress errors if they are not otherwise used.
  48 var _ = proto.Marshal
  49 var _ = fmt.Errorf
  50 var _ = math.Inf
  51
  52 // This is a compile-time assertion to ensure that this generated file
  53 // is compatible with the proto package it is being compiled against.
  54 // A compilation error at this line likely means your copy of the
  55 // proto package needs to be updated.
  56 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  57
  58 func (m *CertificateSigningRequest) Reset()      { *m = CertificateSigningRequest{} }
  59 func (*CertificateSigningRequest) ProtoMessage() {}
  60 func (*CertificateSigningRequest) Descriptor() ([]byte, []int) {
  61         return fileDescriptorGenerated, []int{0}
  62 }
  63
  64 func (m *CertificateSigningRequestCondition) Reset()      { *m = CertificateSigningRequestCondition{} }
  65 func (*CertificateSigningRequestCondition) ProtoMessage() {}
  66 func (*CertificateSigningRequestCondition) Descriptor() ([]byte, []int) {
  67         return fileDescriptorGenerated, []int{1}
  68 }
  69
  70 func (m *CertificateSigningRequestList) Reset()      { *m = CertificateSigningRequestList{} }
  71 func (*CertificateSigningRequestList) ProtoMessage() {}
  72 func (*CertificateSigningRequestList) Descriptor() ([]byte, []int) {
  73         return fileDescriptorGenerated, []int{2}
  74 }
  75
  76 func (m *CertificateSigningRequestSpec) Reset()      { *m = CertificateSigningRequestSpec{} }
  77 func (*CertificateSigningRequestSpec) ProtoMessage() {}
  78 func (*CertificateSigningRequestSpec) Descriptor() ([]byte, []int) {
  79         return fileDescriptorGenerated, []int{3}
  80 }
  81
  82 func (m *CertificateSigningRequestStatus) Reset()      { *m = CertificateSigningRequestStatus{} }
  83 func (*CertificateSigningRequestStatus) ProtoMessage() {}
  84 func (*CertificateSigningRequestStatus) Descriptor() ([]byte, []int) {
  85         return fileDescriptorGenerated, []int{4}
  86 }
  87
  88 func (m *ExtraValue) Reset()                    { *m = ExtraValue{} }
  89 func (*ExtraValue) ProtoMessage()               {}
  90 func (*ExtraValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
  91
  92 func init() {
  93         proto.RegisterType((*CertificateSigningRequest)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequest")
  94         proto.RegisterType((*CertificateSigningRequestCondition)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestCondition")
  95         proto.RegisterType((*CertificateSigningRequestList)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestList")
  96         proto.RegisterType((*CertificateSigningRequestSpec)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestSpec")
  97         proto.RegisterType((*CertificateSigningRequestStatus)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestStatus")
  98         proto.RegisterType((*ExtraValue)(nil), "k8s.io.api.certificates.v1beta1.ExtraValue")
  99 }
 100 func (m *CertificateSigningRequest) Marshal() (dAtA []byte, err error) {
 101         size := m.Size()
 102         dAtA = make([]byte, size)
 103         n, err := m.MarshalTo(dAtA)
 104         if err != nil {
 105                 return nil, err
 106         }
 107         return dAtA[:n], nil
 108 }
 109
 110 func (m *CertificateSigningRequest) MarshalTo(dAtA []byte) (int, error) {
 111         var i int
 112         _ = i
 113         var l int
 114         _ = l
 115         dAtA[i] = 0xa
 116         i++
 117         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 118         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 119         if err != nil {
 120                 return 0, err
 121         }
 122         i += n1
 123         dAtA[i] = 0x12
 124         i++
 125         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 126         n2, err := m.Spec.MarshalTo(dAtA[i:])
 127         if err != nil {
 128                 return 0, err
 129         }
 130         i += n2
 131         dAtA[i] = 0x1a
 132         i++
 133         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 134         n3, err := m.Status.MarshalTo(dAtA[i:])
 135         if err != nil {
 136                 return 0, err
 137         }
 138         i += n3
 139         return i, nil
 140 }
 141
 142 func (m *CertificateSigningRequestCondition) Marshal() (dAtA []byte, err error) {
 143         size := m.Size()
 144         dAtA = make([]byte, size)
 145         n, err := m.MarshalTo(dAtA)
 146         if err != nil {
 147                 return nil, err
 148         }
 149         return dAtA[:n], nil
 150 }
 151
 152 func (m *CertificateSigningRequestCondition) MarshalTo(dAtA []byte) (int, error) {
 153         var i int
 154         _ = i
 155         var l int
 156         _ = l
 157         dAtA[i] = 0xa
 158         i++
 159         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 160         i += copy(dAtA[i:], m.Type)
 161         dAtA[i] = 0x12
 162         i++
 163         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 164         i += copy(dAtA[i:], m.Reason)
 165         dAtA[i] = 0x1a
 166         i++
 167         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 168         i += copy(dAtA[i:], m.Message)
 169         dAtA[i] = 0x22
 170         i++
 171         i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
 172         n4, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
 173         if err != nil {
 174                 return 0, err
 175         }
 176         i += n4
 177         return i, nil
 178 }
 179
 180 func (m *CertificateSigningRequestList) Marshal() (dAtA []byte, err error) {
 181         size := m.Size()
 182         dAtA = make([]byte, size)
 183         n, err := m.MarshalTo(dAtA)
 184         if err != nil {
 185                 return nil, err
 186         }
 187         return dAtA[:n], nil
 188 }
 189
 190 func (m *CertificateSigningRequestList) MarshalTo(dAtA []byte) (int, error) {
 191         var i int
 192         _ = i
 193         var l int
 194         _ = l
 195         dAtA[i] = 0xa
 196         i++
 197         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 198         n5, err := m.ListMeta.MarshalTo(dAtA[i:])
 199         if err != nil {
 200                 return 0, err
 201         }
 202         i += n5
 203         if len(m.Items) > 0 {
 204                 for _, msg := range m.Items {
 205                         dAtA[i] = 0x12
 206                         i++
 207                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 208                         n, err := msg.MarshalTo(dAtA[i:])
 209                         if err != nil {
 210                                 return 0, err
 211                         }
 212                         i += n
 213                 }
 214         }
 215         return i, nil
 216 }
 217
 218 func (m *CertificateSigningRequestSpec) Marshal() (dAtA []byte, err error) {
 219         size := m.Size()
 220         dAtA = make([]byte, size)
 221         n, err := m.MarshalTo(dAtA)
 222         if err != nil {
 223                 return nil, err
 224         }
 225         return dAtA[:n], nil
 226 }
 227
 228 func (m *CertificateSigningRequestSpec) MarshalTo(dAtA []byte) (int, error) {
 229         var i int
 230         _ = i
 231         var l int
 232         _ = l
 233         if m.Request != nil {
 234                 dAtA[i] = 0xa
 235                 i++
 236                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Request)))
 237                 i += copy(dAtA[i:], m.Request)
 238         }
 239         dAtA[i] = 0x12
 240         i++
 241         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Username)))
 242         i += copy(dAtA[i:], m.Username)
 243         dAtA[i] = 0x1a
 244         i++
 245         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
 246         i += copy(dAtA[i:], m.UID)
 247         if len(m.Groups) > 0 {
 248                 for _, s := range m.Groups {
 249                         dAtA[i] = 0x22
 250                         i++
 251                         l = len(s)
 252                         for l >= 1<<7 {
 253                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 254                                 l >>= 7
 255                                 i++
 256                         }
 257                         dAtA[i] = uint8(l)
 258                         i++
 259                         i += copy(dAtA[i:], s)
 260                 }
 261         }
 262         if len(m.Usages) > 0 {
 263                 for _, s := range m.Usages {
 264                         dAtA[i] = 0x2a
 265                         i++
 266                         l = len(s)
 267                         for l >= 1<<7 {
 268                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 269                                 l >>= 7
 270                                 i++
 271                         }
 272                         dAtA[i] = uint8(l)
 273                         i++
 274                         i += copy(dAtA[i:], s)
 275                 }
 276         }
 277         if len(m.Extra) > 0 {
 278                 keysForExtra := make([]string, 0, len(m.Extra))
 279                 for k := range m.Extra {
 280                         keysForExtra = append(keysForExtra, string(k))
 281                 }
 282                 github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
 283                 for _, k := range keysForExtra {
 284                         dAtA[i] = 0x32
 285                         i++
 286                         v := m.Extra[string(k)]
 287                         msgSize := 0
 288                         if (&v) != nil {
 289                                 msgSize = (&v).Size()
 290                                 msgSize += 1 + sovGenerated(uint64(msgSize))
 291                         }
 292                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
 293                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 294                         dAtA[i] = 0xa
 295                         i++
 296                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 297                         i += copy(dAtA[i:], k)
 298                         dAtA[i] = 0x12
 299                         i++
 300                         i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
 301                         n6, err := (&v).MarshalTo(dAtA[i:])
 302                         if err != nil {
 303                                 return 0, err
 304                         }
 305                         i += n6
 306                 }
 307         }
 308         return i, nil
 309 }
 310
 311 func (m *CertificateSigningRequestStatus) Marshal() (dAtA []byte, err error) {
 312         size := m.Size()
 313         dAtA = make([]byte, size)
 314         n, err := m.MarshalTo(dAtA)
 315         if err != nil {
 316                 return nil, err
 317         }
 318         return dAtA[:n], nil
 319 }
 320
 321 func (m *CertificateSigningRequestStatus) MarshalTo(dAtA []byte) (int, error) {
 322         var i int
 323         _ = i
 324         var l int
 325         _ = l
 326         if len(m.Conditions) > 0 {
 327                 for _, msg := range m.Conditions {
 328                         dAtA[i] = 0xa
 329                         i++
 330                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 331                         n, err := msg.MarshalTo(dAtA[i:])
 332                         if err != nil {
 333                                 return 0, err
 334                         }
 335                         i += n
 336                 }
 337         }
 338         if m.Certificate != nil {
 339                 dAtA[i] = 0x12
 340                 i++
 341                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Certificate)))
 342                 i += copy(dAtA[i:], m.Certificate)
 343         }
 344         return i, nil
 345 }
 346
 347 func (m ExtraValue) Marshal() (dAtA []byte, err error) {
 348         size := m.Size()
 349         dAtA = make([]byte, size)
 350         n, err := m.MarshalTo(dAtA)
 351         if err != nil {
 352                 return nil, err
 353         }
 354         return dAtA[:n], nil
 355 }
 356
 357 func (m ExtraValue) MarshalTo(dAtA []byte) (int, error) {
 358         var i int
 359         _ = i
 360         var l int
 361         _ = l
 362         if len(m) > 0 {
 363                 for _, s := range m {
 364                         dAtA[i] = 0xa
 365                         i++
 366                         l = len(s)
 367                         for l >= 1<<7 {
 368                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 369                                 l >>= 7
 370                                 i++
 371                         }
 372                         dAtA[i] = uint8(l)
 373                         i++
 374                         i += copy(dAtA[i:], s)
 375                 }
 376         }
 377         return i, nil
 378 }
 379
 380 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 381         for v >= 1<<7 {
 382                 dAtA[offset] = uint8(v&0x7f | 0x80)
 383                 v >>= 7
 384                 offset++
 385         }
 386         dAtA[offset] = uint8(v)
 387         return offset + 1
 388 }
 389 func (m *CertificateSigningRequest) Size() (n int) {
 390         var l int
 391         _ = l
 392         l = m.ObjectMeta.Size()
 393         n += 1 + l + sovGenerated(uint64(l))
 394         l = m.Spec.Size()
 395         n += 1 + l + sovGenerated(uint64(l))
 396         l = m.Status.Size()
 397         n += 1 + l + sovGenerated(uint64(l))
 398         return n
 399 }
 400
 401 func (m *CertificateSigningRequestCondition) Size() (n int) {
 402         var l int
 403         _ = l
 404         l = len(m.Type)
 405         n += 1 + l + sovGenerated(uint64(l))
 406         l = len(m.Reason)
 407         n += 1 + l + sovGenerated(uint64(l))
 408         l = len(m.Message)
 409         n += 1 + l + sovGenerated(uint64(l))
 410         l = m.LastUpdateTime.Size()
 411         n += 1 + l + sovGenerated(uint64(l))
 412         return n
 413 }
 414
 415 func (m *CertificateSigningRequestList) Size() (n int) {
 416         var l int
 417         _ = l
 418         l = m.ListMeta.Size()
 419         n += 1 + l + sovGenerated(uint64(l))
 420         if len(m.Items) > 0 {
 421                 for _, e := range m.Items {
 422                         l = e.Size()
 423                         n += 1 + l + sovGenerated(uint64(l))
 424                 }
 425         }
 426         return n
 427 }
 428
 429 func (m *CertificateSigningRequestSpec) Size() (n int) {
 430         var l int
 431         _ = l
 432         if m.Request != nil {
 433                 l = len(m.Request)
 434                 n += 1 + l + sovGenerated(uint64(l))
 435         }
 436         l = len(m.Username)
 437         n += 1 + l + sovGenerated(uint64(l))
 438         l = len(m.UID)
 439         n += 1 + l + sovGenerated(uint64(l))
 440         if len(m.Groups) > 0 {
 441                 for _, s := range m.Groups {
 442                         l = len(s)
 443                         n += 1 + l + sovGenerated(uint64(l))
 444                 }
 445         }
 446         if len(m.Usages) > 0 {
 447                 for _, s := range m.Usages {
 448                         l = len(s)
 449                         n += 1 + l + sovGenerated(uint64(l))
 450                 }
 451         }
 452         if len(m.Extra) > 0 {
 453                 for k, v := range m.Extra {
 454                         _ = k
 455                         _ = v
 456                         l = v.Size()
 457                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
 458                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 459                 }
 460         }
 461         return n
 462 }
 463
 464 func (m *CertificateSigningRequestStatus) Size() (n int) {
 465         var l int
 466         _ = l
 467         if len(m.Conditions) > 0 {
 468                 for _, e := range m.Conditions {
 469                         l = e.Size()
 470                         n += 1 + l + sovGenerated(uint64(l))
 471                 }
 472         }
 473         if m.Certificate != nil {
 474                 l = len(m.Certificate)
 475                 n += 1 + l + sovGenerated(uint64(l))
 476         }
 477         return n
 478 }
 479
 480 func (m ExtraValue) Size() (n int) {
 481         var l int
 482         _ = l
 483         if len(m) > 0 {
 484                 for _, s := range m {
 485                         l = len(s)
 486                         n += 1 + l + sovGenerated(uint64(l))
 487                 }
 488         }
 489         return n
 490 }
 491
 492 func sovGenerated(x uint64) (n int) {
 493         for {
 494                 n++
 495                 x >>= 7
 496                 if x == 0 {
 497                         break
 498                 }
 499         }
 500         return n
 501 }
 502 func sozGenerated(x uint64) (n int) {
 503         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 504 }
 505 func (this *CertificateSigningRequest) String() string {
 506         if this == nil {
 507                 return "nil"
 508         }
 509         s := strings.Join([]string{`&CertificateSigningRequest{`,
 510                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 511                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CertificateSigningRequestSpec", "CertificateSigningRequestSpec", 1), `&`, ``, 1) + `,`,
 512                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CertificateSigningRequestStatus", "CertificateSigningRequestStatus", 1), `&`, ``, 1) + `,`,
 513                 `}`,
 514         }, "")
 515         return s
 516 }
 517 func (this *CertificateSigningRequestCondition) String() string {
 518         if this == nil {
 519                 return "nil"
 520         }
 521         s := strings.Join([]string{`&CertificateSigningRequestCondition{`,
 522                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
 523                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
 524                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
 525                 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
 526                 `}`,
 527         }, "")
 528         return s
 529 }
 530 func (this *CertificateSigningRequestList) String() string {
 531         if this == nil {
 532                 return "nil"
 533         }
 534         s := strings.Join([]string{`&CertificateSigningRequestList{`,
 535                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 536                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "CertificateSigningRequest", "CertificateSigningRequest", 1), `&`, ``, 1) + `,`,
 537                 `}`,
 538         }, "")
 539         return s
 540 }
 541 func (this *CertificateSigningRequestSpec) String() string {
 542         if this == nil {
 543                 return "nil"
 544         }
 545         keysForExtra := make([]string, 0, len(this.Extra))
 546         for k := range this.Extra {
 547                 keysForExtra = append(keysForExtra, k)
 548         }
 549         github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
 550         mapStringForExtra := "map[string]ExtraValue{"
 551         for _, k := range keysForExtra {
 552                 mapStringForExtra += fmt.Sprintf("%v: %v,", k, this.Extra[k])
 553         }
 554         mapStringForExtra += "}"
 555         s := strings.Join([]string{`&CertificateSigningRequestSpec{`,
 556                 `Request:` + valueToStringGenerated(this.Request) + `,`,
 557                 `Username:` + fmt.Sprintf("%v", this.Username) + `,`,
 558                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
 559                 `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
 560                 `Usages:` + fmt.Sprintf("%v", this.Usages) + `,`,
 561                 `Extra:` + mapStringForExtra + `,`,
 562                 `}`,
 563         }, "")
 564         return s
 565 }
 566 func (this *CertificateSigningRequestStatus) String() string {
 567         if this == nil {
 568                 return "nil"
 569         }
 570         s := strings.Join([]string{`&CertificateSigningRequestStatus{`,
 571                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "CertificateSigningRequestCondition", "CertificateSigningRequestCondition", 1), `&`, ``, 1) + `,`,
 572                 `Certificate:` + valueToStringGenerated(this.Certificate) + `,`,
 573                 `}`,
 574         }, "")
 575         return s
 576 }
 577 func valueToStringGenerated(v interface{}) string {
 578         rv := reflect.ValueOf(v)
 579         if rv.IsNil() {
 580                 return "nil"
 581         }
 582         pv := reflect.Indirect(rv).Interface()
 583         return fmt.Sprintf("*%v", pv)
 584 }
 585 func (m *CertificateSigningRequest) Unmarshal(dAtA []byte) error {
 586         l := len(dAtA)
 587         iNdEx := 0
 588         for iNdEx < l {
 589                 preIndex := iNdEx
 590                 var wire uint64
 591                 for shift := uint(0); ; shift += 7 {
 592                         if shift >= 64 {
 593                                 return ErrIntOverflowGenerated
 594                         }
 595                         if iNdEx >= l {
 596                                 return io.ErrUnexpectedEOF
 597                         }
 598                         b := dAtA[iNdEx]
 599                         iNdEx++
 600                         wire |= (uint64(b) & 0x7F) << shift
 601                         if b < 0x80 {
 602                                 break
 603                         }
 604                 }
 605                 fieldNum := int32(wire >> 3)
 606                 wireType := int(wire & 0x7)
 607                 if wireType == 4 {
 608                         return fmt.Errorf("proto: CertificateSigningRequest: wiretype end group for non-group")
 609                 }
 610                 if fieldNum <= 0 {
 611                         return fmt.Errorf("proto: CertificateSigningRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 612                 }
 613                 switch fieldNum {
 614                 case 1:
 615                         if wireType != 2 {
 616                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 617                         }
 618                         var msglen int
 619                         for shift := uint(0); ; shift += 7 {
 620                                 if shift >= 64 {
 621                                         return ErrIntOverflowGenerated
 622                                 }
 623                                 if iNdEx >= l {
 624                                         return io.ErrUnexpectedEOF
 625                                 }
 626                                 b := dAtA[iNdEx]
 627                                 iNdEx++
 628                                 msglen |= (int(b) & 0x7F) << shift
 629                                 if b < 0x80 {
 630                                         break
 631                                 }
 632                         }
 633                         if msglen < 0 {
 634                                 return ErrInvalidLengthGenerated
 635                         }
 636                         postIndex := iNdEx + msglen
 637                         if postIndex > l {
 638                                 return io.ErrUnexpectedEOF
 639                         }
 640                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 641                                 return err
 642                         }
 643                         iNdEx = postIndex
 644                 case 2:
 645                         if wireType != 2 {
 646                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 647                         }
 648                         var msglen int
 649                         for shift := uint(0); ; shift += 7 {
 650                                 if shift >= 64 {
 651                                         return ErrIntOverflowGenerated
 652                                 }
 653                                 if iNdEx >= l {
 654                                         return io.ErrUnexpectedEOF
 655                                 }
 656                                 b := dAtA[iNdEx]
 657                                 iNdEx++
 658                                 msglen |= (int(b) & 0x7F) << shift
 659                                 if b < 0x80 {
 660                                         break
 661                                 }
 662                         }
 663                         if msglen < 0 {
 664                                 return ErrInvalidLengthGenerated
 665                         }
 666                         postIndex := iNdEx + msglen
 667                         if postIndex > l {
 668                                 return io.ErrUnexpectedEOF
 669                         }
 670                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 671                                 return err
 672                         }
 673                         iNdEx = postIndex
 674                 case 3:
 675                         if wireType != 2 {
 676                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 677                         }
 678                         var msglen int
 679                         for shift := uint(0); ; shift += 7 {
 680                                 if shift >= 64 {
 681                                         return ErrIntOverflowGenerated
 682                                 }
 683                                 if iNdEx >= l {
 684                                         return io.ErrUnexpectedEOF
 685                                 }
 686                                 b := dAtA[iNdEx]
 687                                 iNdEx++
 688                                 msglen |= (int(b) & 0x7F) << shift
 689                                 if b < 0x80 {
 690                                         break
 691                                 }
 692                         }
 693                         if msglen < 0 {
 694                                 return ErrInvalidLengthGenerated
 695                         }
 696                         postIndex := iNdEx + msglen
 697                         if postIndex > l {
 698                                 return io.ErrUnexpectedEOF
 699                         }
 700                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 701                                 return err
 702                         }
 703                         iNdEx = postIndex
 704                 default:
 705                         iNdEx = preIndex
 706                         skippy, err := skipGenerated(dAtA[iNdEx:])
 707                         if err != nil {
 708                                 return err
 709                         }
 710                         if skippy < 0 {
 711                                 return ErrInvalidLengthGenerated
 712                         }
 713                         if (iNdEx + skippy) > l {
 714                                 return io.ErrUnexpectedEOF
 715                         }
 716                         iNdEx += skippy
 717                 }
 718         }
 719
 720         if iNdEx > l {
 721                 return io.ErrUnexpectedEOF
 722         }
 723         return nil
 724 }
 725 func (m *CertificateSigningRequestCondition) Unmarshal(dAtA []byte) error {
 726         l := len(dAtA)
 727         iNdEx := 0
 728         for iNdEx < l {
 729                 preIndex := iNdEx
 730                 var wire uint64
 731                 for shift := uint(0); ; shift += 7 {
 732                         if shift >= 64 {
 733                                 return ErrIntOverflowGenerated
 734                         }
 735                         if iNdEx >= l {
 736                                 return io.ErrUnexpectedEOF
 737                         }
 738                         b := dAtA[iNdEx]
 739                         iNdEx++
 740                         wire |= (uint64(b) & 0x7F) << shift
 741                         if b < 0x80 {
 742                                 break
 743                         }
 744                 }
 745                 fieldNum := int32(wire >> 3)
 746                 wireType := int(wire & 0x7)
 747                 if wireType == 4 {
 748                         return fmt.Errorf("proto: CertificateSigningRequestCondition: wiretype end group for non-group")
 749                 }
 750                 if fieldNum <= 0 {
 751                         return fmt.Errorf("proto: CertificateSigningRequestCondition: illegal tag %d (wire type %d)", fieldNum, wire)
 752                 }
 753                 switch fieldNum {
 754                 case 1:
 755                         if wireType != 2 {
 756                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
 757                         }
 758                         var stringLen uint64
 759                         for shift := uint(0); ; shift += 7 {
 760                                 if shift >= 64 {
 761                                         return ErrIntOverflowGenerated
 762                                 }
 763                                 if iNdEx >= l {
 764                                         return io.ErrUnexpectedEOF
 765                                 }
 766                                 b := dAtA[iNdEx]
 767                                 iNdEx++
 768                                 stringLen |= (uint64(b) & 0x7F) << shift
 769                                 if b < 0x80 {
 770                                         break
 771                                 }
 772                         }
 773                         intStringLen := int(stringLen)
 774                         if intStringLen < 0 {
 775                                 return ErrInvalidLengthGenerated
 776                         }
 777                         postIndex := iNdEx + intStringLen
 778                         if postIndex > l {
 779                                 return io.ErrUnexpectedEOF
 780                         }
 781                         m.Type = RequestConditionType(dAtA[iNdEx:postIndex])
 782                         iNdEx = postIndex
 783                 case 2:
 784                         if wireType != 2 {
 785                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
 786                         }
 787                         var stringLen uint64
 788                         for shift := uint(0); ; shift += 7 {
 789                                 if shift >= 64 {
 790                                         return ErrIntOverflowGenerated
 791                                 }
 792                                 if iNdEx >= l {
 793                                         return io.ErrUnexpectedEOF
 794                                 }
 795                                 b := dAtA[iNdEx]
 796                                 iNdEx++
 797                                 stringLen |= (uint64(b) & 0x7F) << shift
 798                                 if b < 0x80 {
 799                                         break
 800                                 }
 801                         }
 802                         intStringLen := int(stringLen)
 803                         if intStringLen < 0 {
 804                                 return ErrInvalidLengthGenerated
 805                         }
 806                         postIndex := iNdEx + intStringLen
 807                         if postIndex > l {
 808                                 return io.ErrUnexpectedEOF
 809                         }
 810                         m.Reason = string(dAtA[iNdEx:postIndex])
 811                         iNdEx = postIndex
 812                 case 3:
 813                         if wireType != 2 {
 814                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
 815                         }
 816                         var stringLen uint64
 817                         for shift := uint(0); ; shift += 7 {
 818                                 if shift >= 64 {
 819                                         return ErrIntOverflowGenerated
 820                                 }
 821                                 if iNdEx >= l {
 822                                         return io.ErrUnexpectedEOF
 823                                 }
 824                                 b := dAtA[iNdEx]
 825                                 iNdEx++
 826                                 stringLen |= (uint64(b) & 0x7F) << shift
 827                                 if b < 0x80 {
 828                                         break
 829                                 }
 830                         }
 831                         intStringLen := int(stringLen)
 832                         if intStringLen < 0 {
 833                                 return ErrInvalidLengthGenerated
 834                         }
 835                         postIndex := iNdEx + intStringLen
 836                         if postIndex > l {
 837                                 return io.ErrUnexpectedEOF
 838                         }
 839                         m.Message = string(dAtA[iNdEx:postIndex])
 840                         iNdEx = postIndex
 841                 case 4:
 842                         if wireType != 2 {
 843                                 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
 844                         }
 845                         var msglen int
 846                         for shift := uint(0); ; shift += 7 {
 847                                 if shift >= 64 {
 848                                         return ErrIntOverflowGenerated
 849                                 }
 850                                 if iNdEx >= l {
 851                                         return io.ErrUnexpectedEOF
 852                                 }
 853                                 b := dAtA[iNdEx]
 854                                 iNdEx++
 855                                 msglen |= (int(b) & 0x7F) << shift
 856                                 if b < 0x80 {
 857                                         break
 858                                 }
 859                         }
 860                         if msglen < 0 {
 861                                 return ErrInvalidLengthGenerated
 862                         }
 863                         postIndex := iNdEx + msglen
 864                         if postIndex > l {
 865                                 return io.ErrUnexpectedEOF
 866                         }
 867                         if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 868                                 return err
 869                         }
 870                         iNdEx = postIndex
 871                 default:
 872                         iNdEx = preIndex
 873                         skippy, err := skipGenerated(dAtA[iNdEx:])
 874                         if err != nil {
 875                                 return err
 876                         }
 877                         if skippy < 0 {
 878                                 return ErrInvalidLengthGenerated
 879                         }
 880                         if (iNdEx + skippy) > l {
 881                                 return io.ErrUnexpectedEOF
 882                         }
 883                         iNdEx += skippy
 884                 }
 885         }
 886
 887         if iNdEx > l {
 888                 return io.ErrUnexpectedEOF
 889         }
 890         return nil
 891 }
 892 func (m *CertificateSigningRequestList) Unmarshal(dAtA []byte) error {
 893         l := len(dAtA)
 894         iNdEx := 0
 895         for iNdEx < l {
 896                 preIndex := iNdEx
 897                 var wire uint64
 898                 for shift := uint(0); ; shift += 7 {
 899                         if shift >= 64 {
 900                                 return ErrIntOverflowGenerated
 901                         }
 902                         if iNdEx >= l {
 903                                 return io.ErrUnexpectedEOF
 904                         }
 905                         b := dAtA[iNdEx]
 906                         iNdEx++
 907                         wire |= (uint64(b) & 0x7F) << shift
 908                         if b < 0x80 {
 909                                 break
 910                         }
 911                 }
 912                 fieldNum := int32(wire >> 3)
 913                 wireType := int(wire & 0x7)
 914                 if wireType == 4 {
 915                         return fmt.Errorf("proto: CertificateSigningRequestList: wiretype end group for non-group")
 916                 }
 917                 if fieldNum <= 0 {
 918                         return fmt.Errorf("proto: CertificateSigningRequestList: illegal tag %d (wire type %d)", fieldNum, wire)
 919                 }
 920                 switch fieldNum {
 921                 case 1:
 922                         if wireType != 2 {
 923                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 924                         }
 925                         var msglen int
 926                         for shift := uint(0); ; shift += 7 {
 927                                 if shift >= 64 {
 928                                         return ErrIntOverflowGenerated
 929                                 }
 930                                 if iNdEx >= l {
 931                                         return io.ErrUnexpectedEOF
 932                                 }
 933                                 b := dAtA[iNdEx]
 934                                 iNdEx++
 935                                 msglen |= (int(b) & 0x7F) << shift
 936                                 if b < 0x80 {
 937                                         break
 938                                 }
 939                         }
 940                         if msglen < 0 {
 941                                 return ErrInvalidLengthGenerated
 942                         }
 943                         postIndex := iNdEx + msglen
 944                         if postIndex > l {
 945                                 return io.ErrUnexpectedEOF
 946                         }
 947                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 948                                 return err
 949                         }
 950                         iNdEx = postIndex
 951                 case 2:
 952                         if wireType != 2 {
 953                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 954                         }
 955                         var msglen int
 956                         for shift := uint(0); ; shift += 7 {
 957                                 if shift >= 64 {
 958                                         return ErrIntOverflowGenerated
 959                                 }
 960                                 if iNdEx >= l {
 961                                         return io.ErrUnexpectedEOF
 962                                 }
 963                                 b := dAtA[iNdEx]
 964                                 iNdEx++
 965                                 msglen |= (int(b) & 0x7F) << shift
 966                                 if b < 0x80 {
 967                                         break
 968                                 }
 969                         }
 970                         if msglen < 0 {
 971                                 return ErrInvalidLengthGenerated
 972                         }
 973                         postIndex := iNdEx + msglen
 974                         if postIndex > l {
 975                                 return io.ErrUnexpectedEOF
 976                         }
 977                         m.Items = append(m.Items, CertificateSigningRequest{})
 978                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 979                                 return err
 980                         }
 981                         iNdEx = postIndex
 982                 default:
 983                         iNdEx = preIndex
 984                         skippy, err := skipGenerated(dAtA[iNdEx:])
 985                         if err != nil {
 986                                 return err
 987                         }
 988                         if skippy < 0 {
 989                                 return ErrInvalidLengthGenerated
 990                         }
 991                         if (iNdEx + skippy) > l {
 992                                 return io.ErrUnexpectedEOF
 993                         }
 994                         iNdEx += skippy
 995                 }
 996         }
 997
 998         if iNdEx > l {
 999                 return io.ErrUnexpectedEOF
1000         }
1001         return nil
1002 }
1003 func (m *CertificateSigningRequestSpec) Unmarshal(dAtA []byte) error {
1004         l := len(dAtA)
1005         iNdEx := 0
1006         for iNdEx < l {
1007                 preIndex := iNdEx
1008                 var wire uint64
1009                 for shift := uint(0); ; shift += 7 {
1010                         if shift >= 64 {
1011                                 return ErrIntOverflowGenerated
1012                         }
1013                         if iNdEx >= l {
1014                                 return io.ErrUnexpectedEOF
1015                         }
1016                         b := dAtA[iNdEx]
1017                         iNdEx++
1018                         wire |= (uint64(b) & 0x7F) << shift
1019                         if b < 0x80 {
1020                                 break
1021                         }
1022                 }
1023                 fieldNum := int32(wire >> 3)
1024                 wireType := int(wire & 0x7)
1025                 if wireType == 4 {
1026                         return fmt.Errorf("proto: CertificateSigningRequestSpec: wiretype end group for non-group")
1027                 }
1028                 if fieldNum <= 0 {
1029                         return fmt.Errorf("proto: CertificateSigningRequestSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1030                 }
1031                 switch fieldNum {
1032                 case 1:
1033                         if wireType != 2 {
1034                                 return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
1035                         }
1036                         var byteLen int
1037                         for shift := uint(0); ; shift += 7 {
1038                                 if shift >= 64 {
1039                                         return ErrIntOverflowGenerated
1040                                 }
1041                                 if iNdEx >= l {
1042                                         return io.ErrUnexpectedEOF
1043                                 }
1044                                 b := dAtA[iNdEx]
1045                                 iNdEx++
1046                                 byteLen |= (int(b) & 0x7F) << shift
1047                                 if b < 0x80 {
1048                                         break
1049                                 }
1050                         }
1051                         if byteLen < 0 {
1052                                 return ErrInvalidLengthGenerated
1053                         }
1054                         postIndex := iNdEx + byteLen
1055                         if postIndex > l {
1056                                 return io.ErrUnexpectedEOF
1057                         }
1058                         m.Request = append(m.Request[:0], dAtA[iNdEx:postIndex]...)
1059                         if m.Request == nil {
1060                                 m.Request = []byte{}
1061                         }
1062                         iNdEx = postIndex
1063                 case 2:
1064                         if wireType != 2 {
1065                                 return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
1066                         }
1067                         var stringLen uint64
1068                         for shift := uint(0); ; shift += 7 {
1069                                 if shift >= 64 {
1070                                         return ErrIntOverflowGenerated
1071                                 }
1072                                 if iNdEx >= l {
1073                                         return io.ErrUnexpectedEOF
1074                                 }
1075                                 b := dAtA[iNdEx]
1076                                 iNdEx++
1077                                 stringLen |= (uint64(b) & 0x7F) << shift
1078                                 if b < 0x80 {
1079                                         break
1080                                 }
1081                         }
1082                         intStringLen := int(stringLen)
1083                         if intStringLen < 0 {
1084                                 return ErrInvalidLengthGenerated
1085                         }
1086                         postIndex := iNdEx + intStringLen
1087                         if postIndex > l {
1088                                 return io.ErrUnexpectedEOF
1089                         }
1090                         m.Username = string(dAtA[iNdEx:postIndex])
1091                         iNdEx = postIndex
1092                 case 3:
1093                         if wireType != 2 {
1094                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
1095                         }
1096                         var stringLen uint64
1097                         for shift := uint(0); ; shift += 7 {
1098                                 if shift >= 64 {
1099                                         return ErrIntOverflowGenerated
1100                                 }
1101                                 if iNdEx >= l {
1102                                         return io.ErrUnexpectedEOF
1103                                 }
1104                                 b := dAtA[iNdEx]
1105                                 iNdEx++
1106                                 stringLen |= (uint64(b) & 0x7F) << shift
1107                                 if b < 0x80 {
1108                                         break
1109                                 }
1110                         }
1111                         intStringLen := int(stringLen)
1112                         if intStringLen < 0 {
1113                                 return ErrInvalidLengthGenerated
1114                         }
1115                         postIndex := iNdEx + intStringLen
1116                         if postIndex > l {
1117                                 return io.ErrUnexpectedEOF
1118                         }
1119                         m.UID = string(dAtA[iNdEx:postIndex])
1120                         iNdEx = postIndex
1121                 case 4:
1122                         if wireType != 2 {
1123                                 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
1124                         }
1125                         var stringLen uint64
1126                         for shift := uint(0); ; shift += 7 {
1127                                 if shift >= 64 {
1128                                         return ErrIntOverflowGenerated
1129                                 }
1130                                 if iNdEx >= l {
1131                                         return io.ErrUnexpectedEOF
1132                                 }
1133                                 b := dAtA[iNdEx]
1134                                 iNdEx++
1135                                 stringLen |= (uint64(b) & 0x7F) << shift
1136                                 if b < 0x80 {
1137                                         break
1138                                 }
1139                         }
1140                         intStringLen := int(stringLen)
1141                         if intStringLen < 0 {
1142                                 return ErrInvalidLengthGenerated
1143                         }
1144                         postIndex := iNdEx + intStringLen
1145                         if postIndex > l {
1146                                 return io.ErrUnexpectedEOF
1147                         }
1148                         m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
1149                         iNdEx = postIndex
1150                 case 5:
1151                         if wireType != 2 {
1152                                 return fmt.Errorf("proto: wrong wireType = %d for field Usages", wireType)
1153                         }
1154                         var stringLen uint64
1155                         for shift := uint(0); ; shift += 7 {
1156                                 if shift >= 64 {
1157                                         return ErrIntOverflowGenerated
1158                                 }
1159                                 if iNdEx >= l {
1160                                         return io.ErrUnexpectedEOF
1161                                 }
1162                                 b := dAtA[iNdEx]
1163                                 iNdEx++
1164                                 stringLen |= (uint64(b) & 0x7F) << shift
1165                                 if b < 0x80 {
1166                                         break
1167                                 }
1168                         }
1169                         intStringLen := int(stringLen)
1170                         if intStringLen < 0 {
1171                                 return ErrInvalidLengthGenerated
1172                         }
1173                         postIndex := iNdEx + intStringLen
1174                         if postIndex > l {
1175                                 return io.ErrUnexpectedEOF
1176                         }
1177                         m.Usages = append(m.Usages, KeyUsage(dAtA[iNdEx:postIndex]))
1178                         iNdEx = postIndex
1179                 case 6:
1180                         if wireType != 2 {
1181                                 return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
1182                         }
1183                         var msglen int
1184                         for shift := uint(0); ; shift += 7 {
1185                                 if shift >= 64 {
1186                                         return ErrIntOverflowGenerated
1187                                 }
1188                                 if iNdEx >= l {
1189                                         return io.ErrUnexpectedEOF
1190                                 }
1191                                 b := dAtA[iNdEx]
1192                                 iNdEx++
1193                                 msglen |= (int(b) & 0x7F) << shift
1194                                 if b < 0x80 {
1195                                         break
1196                                 }
1197                         }
1198                         if msglen < 0 {
1199                                 return ErrInvalidLengthGenerated
1200                         }
1201                         postIndex := iNdEx + msglen
1202                         if postIndex > l {
1203                                 return io.ErrUnexpectedEOF
1204                         }
1205                         if m.Extra == nil {
1206                                 m.Extra = make(map[string]ExtraValue)
1207                         }
1208                         var mapkey string
1209                         mapvalue := &ExtraValue{}
1210                         for iNdEx < postIndex {
1211                                 entryPreIndex := iNdEx
1212                                 var wire uint64
1213                                 for shift := uint(0); ; shift += 7 {
1214                                         if shift >= 64 {
1215                                                 return ErrIntOverflowGenerated
1216                                         }
1217                                         if iNdEx >= l {
1218                                                 return io.ErrUnexpectedEOF
1219                                         }
1220                                         b := dAtA[iNdEx]
1221                                         iNdEx++
1222                                         wire |= (uint64(b) & 0x7F) << shift
1223                                         if b < 0x80 {
1224                                                 break
1225                                         }
1226                                 }
1227                                 fieldNum := int32(wire >> 3)
1228                                 if fieldNum == 1 {
1229                                         var stringLenmapkey uint64
1230                                         for shift := uint(0); ; shift += 7 {
1231                                                 if shift >= 64 {
1232                                                         return ErrIntOverflowGenerated
1233                                                 }
1234                                                 if iNdEx >= l {
1235                                                         return io.ErrUnexpectedEOF
1236                                                 }
1237                                                 b := dAtA[iNdEx]
1238                                                 iNdEx++
1239                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
1240                                                 if b < 0x80 {
1241                                                         break
1242                                                 }
1243                                         }
1244                                         intStringLenmapkey := int(stringLenmapkey)
1245                                         if intStringLenmapkey < 0 {
1246                                                 return ErrInvalidLengthGenerated
1247                                         }
1248                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
1249                                         if postStringIndexmapkey > l {
1250                                                 return io.ErrUnexpectedEOF
1251                                         }
1252                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1253                                         iNdEx = postStringIndexmapkey
1254                                 } else if fieldNum == 2 {
1255                                         var mapmsglen int
1256                                         for shift := uint(0); ; shift += 7 {
1257                                                 if shift >= 64 {
1258                                                         return ErrIntOverflowGenerated
1259                                                 }
1260                                                 if iNdEx >= l {
1261                                                         return io.ErrUnexpectedEOF
1262                                                 }
1263                                                 b := dAtA[iNdEx]
1264                                                 iNdEx++
1265                                                 mapmsglen |= (int(b) & 0x7F) << shift
1266                                                 if b < 0x80 {
1267                                                         break
1268                                                 }
1269                                         }
1270                                         if mapmsglen < 0 {
1271                                                 return ErrInvalidLengthGenerated
1272                                         }
1273                                         postmsgIndex := iNdEx + mapmsglen
1274                                         if mapmsglen < 0 {
1275                                                 return ErrInvalidLengthGenerated
1276                                         }
1277                                         if postmsgIndex > l {
1278                                                 return io.ErrUnexpectedEOF
1279                                         }
1280                                         mapvalue = &ExtraValue{}
1281                                         if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
1282                                                 return err
1283                                         }
1284                                         iNdEx = postmsgIndex
1285                                 } else {
1286                                         iNdEx = entryPreIndex
1287                                         skippy, err := skipGenerated(dAtA[iNdEx:])
1288                                         if err != nil {
1289                                                 return err
1290                                         }
1291                                         if skippy < 0 {
1292                                                 return ErrInvalidLengthGenerated
1293                                         }
1294                                         if (iNdEx + skippy) > postIndex {
1295                                                 return io.ErrUnexpectedEOF
1296                                         }
1297                                         iNdEx += skippy
1298                                 }
1299                         }
1300                         m.Extra[mapkey] = *mapvalue
1301                         iNdEx = postIndex
1302                 default:
1303                         iNdEx = preIndex
1304                         skippy, err := skipGenerated(dAtA[iNdEx:])
1305                         if err != nil {
1306                                 return err
1307                         }
1308                         if skippy < 0 {
1309                                 return ErrInvalidLengthGenerated
1310                         }
1311                         if (iNdEx + skippy) > l {
1312                                 return io.ErrUnexpectedEOF
1313                         }
1314                         iNdEx += skippy
1315                 }
1316         }
1317
1318         if iNdEx > l {
1319                 return io.ErrUnexpectedEOF
1320         }
1321         return nil
1322 }
1323 func (m *CertificateSigningRequestStatus) Unmarshal(dAtA []byte) error {
1324         l := len(dAtA)
1325         iNdEx := 0
1326         for iNdEx < l {
1327                 preIndex := iNdEx
1328                 var wire uint64
1329                 for shift := uint(0); ; shift += 7 {
1330                         if shift >= 64 {
1331                                 return ErrIntOverflowGenerated
1332                         }
1333                         if iNdEx >= l {
1334                                 return io.ErrUnexpectedEOF
1335                         }
1336                         b := dAtA[iNdEx]
1337                         iNdEx++
1338                         wire |= (uint64(b) & 0x7F) << shift
1339                         if b < 0x80 {
1340                                 break
1341                         }
1342                 }
1343                 fieldNum := int32(wire >> 3)
1344                 wireType := int(wire & 0x7)
1345                 if wireType == 4 {
1346                         return fmt.Errorf("proto: CertificateSigningRequestStatus: wiretype end group for non-group")
1347                 }
1348                 if fieldNum <= 0 {
1349                         return fmt.Errorf("proto: CertificateSigningRequestStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1350                 }
1351                 switch fieldNum {
1352                 case 1:
1353                         if wireType != 2 {
1354                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
1355                         }
1356                         var msglen int
1357                         for shift := uint(0); ; shift += 7 {
1358                                 if shift >= 64 {
1359                                         return ErrIntOverflowGenerated
1360                                 }
1361                                 if iNdEx >= l {
1362                                         return io.ErrUnexpectedEOF
1363                                 }
1364                                 b := dAtA[iNdEx]
1365                                 iNdEx++
1366                                 msglen |= (int(b) & 0x7F) << shift
1367                                 if b < 0x80 {
1368                                         break
1369                                 }
1370                         }
1371                         if msglen < 0 {
1372                                 return ErrInvalidLengthGenerated
1373                         }
1374                         postIndex := iNdEx + msglen
1375                         if postIndex > l {
1376                                 return io.ErrUnexpectedEOF
1377                         }
1378                         m.Conditions = append(m.Conditions, CertificateSigningRequestCondition{})
1379                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1380                                 return err
1381                         }
1382                         iNdEx = postIndex
1383                 case 2:
1384                         if wireType != 2 {
1385                                 return fmt.Errorf("proto: wrong wireType = %d for field Certificate", wireType)
1386                         }
1387                         var byteLen int
1388                         for shift := uint(0); ; shift += 7 {
1389                                 if shift >= 64 {
1390                                         return ErrIntOverflowGenerated
1391                                 }
1392                                 if iNdEx >= l {
1393                                         return io.ErrUnexpectedEOF
1394                                 }
1395                                 b := dAtA[iNdEx]
1396                                 iNdEx++
1397                                 byteLen |= (int(b) & 0x7F) << shift
1398                                 if b < 0x80 {
1399                                         break
1400                                 }
1401                         }
1402                         if byteLen < 0 {
1403                                 return ErrInvalidLengthGenerated
1404                         }
1405                         postIndex := iNdEx + byteLen
1406                         if postIndex > l {
1407                                 return io.ErrUnexpectedEOF
1408                         }
1409                         m.Certificate = append(m.Certificate[:0], dAtA[iNdEx:postIndex]...)
1410                         if m.Certificate == nil {
1411                                 m.Certificate = []byte{}
1412                         }
1413                         iNdEx = postIndex
1414                 default:
1415                         iNdEx = preIndex
1416                         skippy, err := skipGenerated(dAtA[iNdEx:])
1417                         if err != nil {
1418                                 return err
1419                         }
1420                         if skippy < 0 {
1421                                 return ErrInvalidLengthGenerated
1422                         }
1423                         if (iNdEx + skippy) > l {
1424                                 return io.ErrUnexpectedEOF
1425                         }
1426                         iNdEx += skippy
1427                 }
1428         }
1429
1430         if iNdEx > l {
1431                 return io.ErrUnexpectedEOF
1432         }
1433         return nil
1434 }
1435 func (m *ExtraValue) Unmarshal(dAtA []byte) error {
1436         l := len(dAtA)
1437         iNdEx := 0
1438         for iNdEx < l {
1439                 preIndex := iNdEx
1440                 var wire uint64
1441                 for shift := uint(0); ; shift += 7 {
1442                         if shift >= 64 {
1443                                 return ErrIntOverflowGenerated
1444                         }
1445                         if iNdEx >= l {
1446                                 return io.ErrUnexpectedEOF
1447                         }
1448                         b := dAtA[iNdEx]
1449                         iNdEx++
1450                         wire |= (uint64(b) & 0x7F) << shift
1451                         if b < 0x80 {
1452                                 break
1453                         }
1454                 }
1455                 fieldNum := int32(wire >> 3)
1456                 wireType := int(wire & 0x7)
1457                 if wireType == 4 {
1458                         return fmt.Errorf("proto: ExtraValue: wiretype end group for non-group")
1459                 }
1460                 if fieldNum <= 0 {
1461                         return fmt.Errorf("proto: ExtraValue: illegal tag %d (wire type %d)", fieldNum, wire)
1462                 }
1463                 switch fieldNum {
1464                 case 1:
1465                         if wireType != 2 {
1466                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1467                         }
1468                         var stringLen uint64
1469                         for shift := uint(0); ; shift += 7 {
1470                                 if shift >= 64 {
1471                                         return ErrIntOverflowGenerated
1472                                 }
1473                                 if iNdEx >= l {
1474                                         return io.ErrUnexpectedEOF
1475                                 }
1476                                 b := dAtA[iNdEx]
1477                                 iNdEx++
1478                                 stringLen |= (uint64(b) & 0x7F) << shift
1479                                 if b < 0x80 {
1480                                         break
1481                                 }
1482                         }
1483                         intStringLen := int(stringLen)
1484                         if intStringLen < 0 {
1485                                 return ErrInvalidLengthGenerated
1486                         }
1487                         postIndex := iNdEx + intStringLen
1488                         if postIndex > l {
1489                                 return io.ErrUnexpectedEOF
1490                         }
1491                         *m = append(*m, string(dAtA[iNdEx:postIndex]))
1492                         iNdEx = postIndex
1493                 default:
1494                         iNdEx = preIndex
1495                         skippy, err := skipGenerated(dAtA[iNdEx:])
1496                         if err != nil {
1497                                 return err
1498                         }
1499                         if skippy < 0 {
1500                                 return ErrInvalidLengthGenerated
1501                         }
1502                         if (iNdEx + skippy) > l {
1503                                 return io.ErrUnexpectedEOF
1504                         }
1505                         iNdEx += skippy
1506                 }
1507         }
1508
1509         if iNdEx > l {
1510                 return io.ErrUnexpectedEOF
1511         }
1512         return nil
1513 }
1514 func skipGenerated(dAtA []byte) (n int, err error) {
1515         l := len(dAtA)
1516         iNdEx := 0
1517         for iNdEx < l {
1518                 var wire uint64
1519                 for shift := uint(0); ; shift += 7 {
1520                         if shift >= 64 {
1521                                 return 0, ErrIntOverflowGenerated
1522                         }
1523                         if iNdEx >= l {
1524                                 return 0, io.ErrUnexpectedEOF
1525                         }
1526                         b := dAtA[iNdEx]
1527                         iNdEx++
1528                         wire |= (uint64(b) & 0x7F) << shift
1529                         if b < 0x80 {
1530                                 break
1531                         }
1532                 }
1533                 wireType := int(wire & 0x7)
1534                 switch wireType {
1535                 case 0:
1536                         for shift := uint(0); ; shift += 7 {
1537                                 if shift >= 64 {
1538                                         return 0, ErrIntOverflowGenerated
1539                                 }
1540                                 if iNdEx >= l {
1541                                         return 0, io.ErrUnexpectedEOF
1542                                 }
1543                                 iNdEx++
1544                                 if dAtA[iNdEx-1] < 0x80 {
1545                                         break
1546                                 }
1547                         }
1548                         return iNdEx, nil
1549                 case 1:
1550                         iNdEx += 8
1551                         return iNdEx, nil
1552                 case 2:
1553                         var length int
1554                         for shift := uint(0); ; shift += 7 {
1555                                 if shift >= 64 {
1556                                         return 0, ErrIntOverflowGenerated
1557                                 }
1558                                 if iNdEx >= l {
1559                                         return 0, io.ErrUnexpectedEOF
1560                                 }
1561                                 b := dAtA[iNdEx]
1562                                 iNdEx++
1563                                 length |= (int(b) & 0x7F) << shift
1564                                 if b < 0x80 {
1565                                         break
1566                                 }
1567                         }
1568                         iNdEx += length
1569                         if length < 0 {
1570                                 return 0, ErrInvalidLengthGenerated
1571                         }
1572                         return iNdEx, nil
1573                 case 3:
1574                         for {
1575                                 var innerWire uint64
1576                                 var start int = iNdEx
1577                                 for shift := uint(0); ; shift += 7 {
1578                                         if shift >= 64 {
1579                                                 return 0, ErrIntOverflowGenerated
1580                                         }
1581                                         if iNdEx >= l {
1582                                                 return 0, io.ErrUnexpectedEOF
1583                                         }
1584                                         b := dAtA[iNdEx]
1585                                         iNdEx++
1586                                         innerWire |= (uint64(b) & 0x7F) << shift
1587                                         if b < 0x80 {
1588                                                 break
1589                                         }
1590                                 }
1591                                 innerWireType := int(innerWire & 0x7)
1592                                 if innerWireType == 4 {
1593                                         break
1594                                 }
1595                                 next, err := skipGenerated(dAtA[start:])
1596                                 if err != nil {
1597                                         return 0, err
1598                                 }
1599                                 iNdEx = start + next
1600                         }
1601                         return iNdEx, nil
1602                 case 4:
1603                         return iNdEx, nil
1604                 case 5:
1605                         iNdEx += 4
1606                         return iNdEx, nil
1607                 default:
1608                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1609                 }
1610         }
1611         panic("unreachable")
1612 }
1613
1614 var (
1615         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1616         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
1617 )
1618
1619 func init() {
1620         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto", fileDescriptorGenerated)
1621 }
1622
1623 var fileDescriptorGenerated = []byte{
1624         // 804 bytes of a gzipped FileDescriptorProto
1625         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x8f, 0xdb, 0x44,
1626         0x18, 0x8e, 0xf3, 0xb5, 0xc9, 0x64, 0xd9, 0x56, 0x23, 0x54, 0x99, 0x95, 0x6a, 0xaf, 0x2c, 0x40,
1627         0xcb, 0x47, 0xc7, 0x6c, 0x85, 0x60, 0xb5, 0x07, 0x04, 0x5e, 0x2a, 0x58, 0xd1, 0x0a, 0x69, 0xda,
1628         0x70, 0x40, 0x48, 0x74, 0xe2, 0xbc, 0x75, 0xa6, 0xa9, 0x3f, 0xf0, 0x8c, 0x03, 0xb9, 0xf5, 0x27,
1629         0x70, 0xe4, 0x82, 0xc4, 0x2f, 0xe1, 0xbc, 0x1c, 0x90, 0x7a, 0xec, 0x01, 0x45, 0x6c, 0xf8, 0x17,
1630         0x3d, 0xa1, 0x19, 0x4f, 0xe2, 0x90, 0x55, 0x48, 0xd5, 0xbd, 0x79, 0x9e, 0xf7, 0x79, 0x9e, 0xf7,
1631         0x63, 0xde, 0x31, 0xfa, 0x72, 0x7c, 0x2c, 0x08, 0x4f, 0xfd, 0x71, 0x31, 0x80, 0x3c, 0x01, 0x09,
1632         0xc2, 0x9f, 0x40, 0x32, 0x4c, 0x73, 0xdf, 0x04, 0x58, 0xc6, 0xfd, 0x10, 0x72, 0xc9, 0x1f, 0xf1,
1633         0x90, 0xe9, 0xf0, 0xd1, 0x00, 0x24, 0x3b, 0xf2, 0x23, 0x48, 0x20, 0x67, 0x12, 0x86, 0x24, 0xcb,
1634         0x53, 0x99, 0x62, 0xb7, 0x14, 0x10, 0x96, 0x71, 0xb2, 0x2a, 0x20, 0x46, 0xb0, 0x7f, 0x2b, 0xe2,
1635         0x72, 0x54, 0x0c, 0x48, 0x98, 0xc6, 0x7e, 0x94, 0x46, 0xa9, 0xaf, 0x75, 0x83, 0xe2, 0x91, 0x3e,
1636         0xe9, 0x83, 0xfe, 0x2a, 0xfd, 0xf6, 0x3f, 0xac, 0x0a, 0x88, 0x59, 0x38, 0xe2, 0x09, 0xe4, 0x53,
1637         0x3f, 0x1b, 0x47, 0x0a, 0x10, 0x7e, 0x0c, 0x92, 0xf9, 0x93, 0x4b, 0x55, 0xec, 0xfb, 0x9b, 0x54,
1638         0x79, 0x91, 0x48, 0x1e, 0xc3, 0x25, 0xc1, 0x47, 0xdb, 0x04, 0x22, 0x1c, 0x41, 0xcc, 0xd6, 0x75,
1639         0xde, 0x1f, 0x75, 0xf4, 0xc6, 0x69, 0xd5, 0xe6, 0x7d, 0x1e, 0x25, 0x3c, 0x89, 0x28, 0xfc, 0x50,
1640         0x80, 0x90, 0xf8, 0x21, 0xea, 0xa8, 0x0a, 0x87, 0x4c, 0x32, 0xdb, 0x3a, 0xb0, 0x0e, 0x7b, 0xb7,
1641         0x3f, 0x20, 0xd5, 0x7c, 0x96, 0x89, 0x48, 0x36, 0x8e, 0x14, 0x20, 0x88, 0x62, 0x93, 0xc9, 0x11,
1642         0xf9, 0x7a, 0xf0, 0x18, 0x42, 0x79, 0x0f, 0x24, 0x0b, 0xf0, 0xf9, 0xcc, 0xad, 0xcd, 0x67, 0x2e,
1643         0xaa, 0x30, 0xba, 0x74, 0xc5, 0x0f, 0x51, 0x53, 0x64, 0x10, 0xda, 0x75, 0xed, 0xfe, 0x09, 0xd9,
1644         0x32, 0x7d, 0xb2, 0xb1, 0xd6, 0xfb, 0x19, 0x84, 0xc1, 0xae, 0xc9, 0xd5, 0x54, 0x27, 0xaa, 0x9d,
1645         0xf1, 0x08, 0xb5, 0x85, 0x64, 0xb2, 0x10, 0x76, 0x43, 0xe7, 0xf8, 0xf4, 0x0a, 0x39, 0xb4, 0x4f,
1646         0xb0, 0x67, 0xb2, 0xb4, 0xcb, 0x33, 0x35, 0xfe, 0xde, 0xaf, 0x75, 0xe4, 0x6d, 0xd4, 0x9e, 0xa6,
1647         0xc9, 0x90, 0x4b, 0x9e, 0x26, 0xf8, 0x18, 0x35, 0xe5, 0x34, 0x03, 0x3d, 0xd0, 0x6e, 0xf0, 0xe6,
1648         0xa2, 0xe4, 0x07, 0xd3, 0x0c, 0x5e, 0xcc, 0xdc, 0xd7, 0xd7, 0xf9, 0x0a, 0xa7, 0x5a, 0x81, 0xdf,
1649         0x46, 0xed, 0x1c, 0x98, 0x48, 0x13, 0x3d, 0xae, 0x6e, 0x55, 0x08, 0xd5, 0x28, 0x35, 0x51, 0xfc,
1650         0x0e, 0xda, 0x89, 0x41, 0x08, 0x16, 0x81, 0xee, 0xb9, 0x1b, 0x5c, 0x33, 0xc4, 0x9d, 0x7b, 0x25,
1651         0x4c, 0x17, 0x71, 0xfc, 0x18, 0xed, 0x3d, 0x61, 0x42, 0xf6, 0xb3, 0x21, 0x93, 0xf0, 0x80, 0xc7,
1652         0x60, 0x37, 0xf5, 0x94, 0xde, 0x7d, 0xb9, 0x7b, 0x56, 0x8a, 0xe0, 0x86, 0x71, 0xdf, 0xbb, 0xfb,
1653         0x1f, 0x27, 0xba, 0xe6, 0xec, 0xcd, 0x2c, 0x74, 0x73, 0xe3, 0x7c, 0xee, 0x72, 0x21, 0xf1, 0x77,
1654         0x97, 0xf6, 0x8d, 0xbc, 0x5c, 0x1d, 0x4a, 0xad, 0xb7, 0xed, 0xba, 0xa9, 0xa5, 0xb3, 0x40, 0x56,
1655         0x76, 0xed, 0x7b, 0xd4, 0xe2, 0x12, 0x62, 0x61, 0xd7, 0x0f, 0x1a, 0x87, 0xbd, 0xdb, 0x27, 0xaf,
1656         0xbe, 0x08, 0xc1, 0x6b, 0x26, 0x4d, 0xeb, 0x4c, 0x19, 0xd2, 0xd2, 0xd7, 0xfb, 0xbd, 0xf1, 0x3f,
1657         0x0d, 0xaa, 0x95, 0xc4, 0x6f, 0xa1, 0x9d, 0xbc, 0x3c, 0xea, 0xfe, 0x76, 0x83, 0x9e, 0xba, 0x15,
1658         0xc3, 0xa0, 0x8b, 0x18, 0x7e, 0x1f, 0x75, 0x0a, 0x01, 0x79, 0xc2, 0x62, 0x30, 0x57, 0xbd, 0xec,
1659         0xab, 0x6f, 0x70, 0xba, 0x64, 0xe0, 0x9b, 0xa8, 0x51, 0xf0, 0xa1, 0xb9, 0xea, 0x9e, 0x21, 0x36,
1660         0xfa, 0x67, 0x9f, 0x53, 0x85, 0x63, 0x0f, 0xb5, 0xa3, 0x3c, 0x2d, 0x32, 0x61, 0x37, 0x0f, 0x1a,
1661         0x87, 0xdd, 0x00, 0xa9, 0x8d, 0xf9, 0x42, 0x23, 0xd4, 0x44, 0x30, 0x41, 0xed, 0x42, 0xed, 0x83,
1662         0xb0, 0x5b, 0x9a, 0x73, 0x43, 0x71, 0xfa, 0x1a, 0x79, 0x31, 0x73, 0x3b, 0x5f, 0xc1, 0x54, 0x1f,
1663         0xa8, 0x61, 0xe1, 0x04, 0xb5, 0xe0, 0x27, 0x99, 0x33, 0xbb, 0xad, 0x47, 0x79, 0x76, 0xb5, 0x77,
1664         0x4b, 0xee, 0x28, 0xaf, 0x3b, 0x89, 0xcc, 0xa7, 0xd5, 0x64, 0x35, 0x46, 0xcb, 0x34, 0xfb, 0x80,
1665         0x50, 0xc5, 0xc1, 0xd7, 0x51, 0x63, 0x0c, 0xd3, 0xf2, 0x01, 0x51, 0xf5, 0x89, 0x3f, 0x43, 0xad,
1666         0x09, 0x7b, 0x52, 0x80, 0xf9, 0x8f, 0xbc, 0xb7, 0xb5, 0x1e, 0xed, 0xf6, 0x8d, 0x92, 0xd0, 0x52,
1667         0x79, 0x52, 0x3f, 0xb6, 0xbc, 0x3f, 0x2d, 0xe4, 0x6e, 0x79, 0xfd, 0xf8, 0x47, 0x84, 0xc2, 0xc5,
1668         0xdb, 0x14, 0xb6, 0xa5, 0xfb, 0x3f, 0x7d, 0xf5, 0xfe, 0x97, 0xef, 0xbc, 0xfa, 0x51, 0x2e, 0x21,
1669         0x41, 0x57, 0x52, 0xe1, 0x23, 0xd4, 0x5b, 0xb1, 0xd6, 0x9d, 0xee, 0x06, 0xd7, 0xe6, 0x33, 0xb7,
1670         0xb7, 0x62, 0x4e, 0x57, 0x39, 0xde, 0xc7, 0x66, 0x6c, 0xba, 0x51, 0xec, 0x2e, 0xf6, 0xdf, 0xd2,
1671         0x77, 0xdc, 0x5d, 0xdf, 0xdf, 0x93, 0xce, 0x2f, 0xbf, 0xb9, 0xb5, 0xa7, 0x7f, 0x1d, 0xd4, 0x82,
1672         0x5b, 0xe7, 0x17, 0x4e, 0xed, 0xd9, 0x85, 0x53, 0x7b, 0x7e, 0xe1, 0xd4, 0x9e, 0xce, 0x1d, 0xeb,
1673         0x7c, 0xee, 0x58, 0xcf, 0xe6, 0x8e, 0xf5, 0x7c, 0xee, 0x58, 0x7f, 0xcf, 0x1d, 0xeb, 0xe7, 0x7f,
1674         0x9c, 0xda, 0xb7, 0x3b, 0xa6, 0xbb, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xb7, 0x6b, 0x5b, 0xf9,
1675         0x7f, 0x07, 0x00, 0x00,
1676 }