cmd/bpa-operator/vendor/k8s.io/api/authentication/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/authentication/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/authentication/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 ExtraValue
  28                 TokenReview
  29                 TokenReviewSpec
  30                 TokenReviewStatus
  31                 UserInfo
  32 */
  33 package v1beta1
  34
  35 import proto "github.com/gogo/protobuf/proto"
  36 import fmt "fmt"
  37 import math "math"
  38
  39 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  40
  41 import strings "strings"
  42 import reflect "reflect"
  43
  44 import io "io"
  45
  46 // Reference imports to suppress errors if they are not otherwise used.
  47 var _ = proto.Marshal
  48 var _ = fmt.Errorf
  49 var _ = math.Inf
  50
  51 // This is a compile-time assertion to ensure that this generated file
  52 // is compatible with the proto package it is being compiled against.
  53 // A compilation error at this line likely means your copy of the
  54 // proto package needs to be updated.
  55 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  56
  57 func (m *ExtraValue) Reset()                    { *m = ExtraValue{} }
  58 func (*ExtraValue) ProtoMessage()               {}
  59 func (*ExtraValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  60
  61 func (m *TokenReview) Reset()                    { *m = TokenReview{} }
  62 func (*TokenReview) ProtoMessage()               {}
  63 func (*TokenReview) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  64
  65 func (m *TokenReviewSpec) Reset()                    { *m = TokenReviewSpec{} }
  66 func (*TokenReviewSpec) ProtoMessage()               {}
  67 func (*TokenReviewSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  68
  69 func (m *TokenReviewStatus) Reset()                    { *m = TokenReviewStatus{} }
  70 func (*TokenReviewStatus) ProtoMessage()               {}
  71 func (*TokenReviewStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
  72
  73 func (m *UserInfo) Reset()                    { *m = UserInfo{} }
  74 func (*UserInfo) ProtoMessage()               {}
  75 func (*UserInfo) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
  76
  77 func init() {
  78         proto.RegisterType((*ExtraValue)(nil), "k8s.io.api.authentication.v1beta1.ExtraValue")
  79         proto.RegisterType((*TokenReview)(nil), "k8s.io.api.authentication.v1beta1.TokenReview")
  80         proto.RegisterType((*TokenReviewSpec)(nil), "k8s.io.api.authentication.v1beta1.TokenReviewSpec")
  81         proto.RegisterType((*TokenReviewStatus)(nil), "k8s.io.api.authentication.v1beta1.TokenReviewStatus")
  82         proto.RegisterType((*UserInfo)(nil), "k8s.io.api.authentication.v1beta1.UserInfo")
  83 }
  84 func (m ExtraValue) Marshal() (dAtA []byte, err error) {
  85         size := m.Size()
  86         dAtA = make([]byte, size)
  87         n, err := m.MarshalTo(dAtA)
  88         if err != nil {
  89                 return nil, err
  90         }
  91         return dAtA[:n], nil
  92 }
  93
  94 func (m ExtraValue) MarshalTo(dAtA []byte) (int, error) {
  95         var i int
  96         _ = i
  97         var l int
  98         _ = l
  99         if len(m) > 0 {
 100                 for _, s := range m {
 101                         dAtA[i] = 0xa
 102                         i++
 103                         l = len(s)
 104                         for l >= 1<<7 {
 105                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 106                                 l >>= 7
 107                                 i++
 108                         }
 109                         dAtA[i] = uint8(l)
 110                         i++
 111                         i += copy(dAtA[i:], s)
 112                 }
 113         }
 114         return i, nil
 115 }
 116
 117 func (m *TokenReview) Marshal() (dAtA []byte, err error) {
 118         size := m.Size()
 119         dAtA = make([]byte, size)
 120         n, err := m.MarshalTo(dAtA)
 121         if err != nil {
 122                 return nil, err
 123         }
 124         return dAtA[:n], nil
 125 }
 126
 127 func (m *TokenReview) MarshalTo(dAtA []byte) (int, error) {
 128         var i int
 129         _ = i
 130         var l int
 131         _ = l
 132         dAtA[i] = 0xa
 133         i++
 134         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 135         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 136         if err != nil {
 137                 return 0, err
 138         }
 139         i += n1
 140         dAtA[i] = 0x12
 141         i++
 142         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 143         n2, err := m.Spec.MarshalTo(dAtA[i:])
 144         if err != nil {
 145                 return 0, err
 146         }
 147         i += n2
 148         dAtA[i] = 0x1a
 149         i++
 150         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 151         n3, err := m.Status.MarshalTo(dAtA[i:])
 152         if err != nil {
 153                 return 0, err
 154         }
 155         i += n3
 156         return i, nil
 157 }
 158
 159 func (m *TokenReviewSpec) Marshal() (dAtA []byte, err error) {
 160         size := m.Size()
 161         dAtA = make([]byte, size)
 162         n, err := m.MarshalTo(dAtA)
 163         if err != nil {
 164                 return nil, err
 165         }
 166         return dAtA[:n], nil
 167 }
 168
 169 func (m *TokenReviewSpec) MarshalTo(dAtA []byte) (int, error) {
 170         var i int
 171         _ = i
 172         var l int
 173         _ = l
 174         dAtA[i] = 0xa
 175         i++
 176         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Token)))
 177         i += copy(dAtA[i:], m.Token)
 178         if len(m.Audiences) > 0 {
 179                 for _, s := range m.Audiences {
 180                         dAtA[i] = 0x12
 181                         i++
 182                         l = len(s)
 183                         for l >= 1<<7 {
 184                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 185                                 l >>= 7
 186                                 i++
 187                         }
 188                         dAtA[i] = uint8(l)
 189                         i++
 190                         i += copy(dAtA[i:], s)
 191                 }
 192         }
 193         return i, nil
 194 }
 195
 196 func (m *TokenReviewStatus) Marshal() (dAtA []byte, err error) {
 197         size := m.Size()
 198         dAtA = make([]byte, size)
 199         n, err := m.MarshalTo(dAtA)
 200         if err != nil {
 201                 return nil, err
 202         }
 203         return dAtA[:n], nil
 204 }
 205
 206 func (m *TokenReviewStatus) MarshalTo(dAtA []byte) (int, error) {
 207         var i int
 208         _ = i
 209         var l int
 210         _ = l
 211         dAtA[i] = 0x8
 212         i++
 213         if m.Authenticated {
 214                 dAtA[i] = 1
 215         } else {
 216                 dAtA[i] = 0
 217         }
 218         i++
 219         dAtA[i] = 0x12
 220         i++
 221         i = encodeVarintGenerated(dAtA, i, uint64(m.User.Size()))
 222         n4, err := m.User.MarshalTo(dAtA[i:])
 223         if err != nil {
 224                 return 0, err
 225         }
 226         i += n4
 227         dAtA[i] = 0x1a
 228         i++
 229         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Error)))
 230         i += copy(dAtA[i:], m.Error)
 231         if len(m.Audiences) > 0 {
 232                 for _, s := range m.Audiences {
 233                         dAtA[i] = 0x22
 234                         i++
 235                         l = len(s)
 236                         for l >= 1<<7 {
 237                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 238                                 l >>= 7
 239                                 i++
 240                         }
 241                         dAtA[i] = uint8(l)
 242                         i++
 243                         i += copy(dAtA[i:], s)
 244                 }
 245         }
 246         return i, nil
 247 }
 248
 249 func (m *UserInfo) Marshal() (dAtA []byte, err error) {
 250         size := m.Size()
 251         dAtA = make([]byte, size)
 252         n, err := m.MarshalTo(dAtA)
 253         if err != nil {
 254                 return nil, err
 255         }
 256         return dAtA[:n], nil
 257 }
 258
 259 func (m *UserInfo) MarshalTo(dAtA []byte) (int, error) {
 260         var i int
 261         _ = i
 262         var l int
 263         _ = l
 264         dAtA[i] = 0xa
 265         i++
 266         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Username)))
 267         i += copy(dAtA[i:], m.Username)
 268         dAtA[i] = 0x12
 269         i++
 270         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
 271         i += copy(dAtA[i:], m.UID)
 272         if len(m.Groups) > 0 {
 273                 for _, s := range m.Groups {
 274                         dAtA[i] = 0x1a
 275                         i++
 276                         l = len(s)
 277                         for l >= 1<<7 {
 278                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 279                                 l >>= 7
 280                                 i++
 281                         }
 282                         dAtA[i] = uint8(l)
 283                         i++
 284                         i += copy(dAtA[i:], s)
 285                 }
 286         }
 287         if len(m.Extra) > 0 {
 288                 keysForExtra := make([]string, 0, len(m.Extra))
 289                 for k := range m.Extra {
 290                         keysForExtra = append(keysForExtra, string(k))
 291                 }
 292                 github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
 293                 for _, k := range keysForExtra {
 294                         dAtA[i] = 0x22
 295                         i++
 296                         v := m.Extra[string(k)]
 297                         msgSize := 0
 298                         if (&v) != nil {
 299                                 msgSize = (&v).Size()
 300                                 msgSize += 1 + sovGenerated(uint64(msgSize))
 301                         }
 302                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
 303                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 304                         dAtA[i] = 0xa
 305                         i++
 306                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 307                         i += copy(dAtA[i:], k)
 308                         dAtA[i] = 0x12
 309                         i++
 310                         i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
 311                         n5, err := (&v).MarshalTo(dAtA[i:])
 312                         if err != nil {
 313                                 return 0, err
 314                         }
 315                         i += n5
 316                 }
 317         }
 318         return i, nil
 319 }
 320
 321 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 322         for v >= 1<<7 {
 323                 dAtA[offset] = uint8(v&0x7f | 0x80)
 324                 v >>= 7
 325                 offset++
 326         }
 327         dAtA[offset] = uint8(v)
 328         return offset + 1
 329 }
 330 func (m ExtraValue) Size() (n int) {
 331         var l int
 332         _ = l
 333         if len(m) > 0 {
 334                 for _, s := range m {
 335                         l = len(s)
 336                         n += 1 + l + sovGenerated(uint64(l))
 337                 }
 338         }
 339         return n
 340 }
 341
 342 func (m *TokenReview) Size() (n int) {
 343         var l int
 344         _ = l
 345         l = m.ObjectMeta.Size()
 346         n += 1 + l + sovGenerated(uint64(l))
 347         l = m.Spec.Size()
 348         n += 1 + l + sovGenerated(uint64(l))
 349         l = m.Status.Size()
 350         n += 1 + l + sovGenerated(uint64(l))
 351         return n
 352 }
 353
 354 func (m *TokenReviewSpec) Size() (n int) {
 355         var l int
 356         _ = l
 357         l = len(m.Token)
 358         n += 1 + l + sovGenerated(uint64(l))
 359         if len(m.Audiences) > 0 {
 360                 for _, s := range m.Audiences {
 361                         l = len(s)
 362                         n += 1 + l + sovGenerated(uint64(l))
 363                 }
 364         }
 365         return n
 366 }
 367
 368 func (m *TokenReviewStatus) Size() (n int) {
 369         var l int
 370         _ = l
 371         n += 2
 372         l = m.User.Size()
 373         n += 1 + l + sovGenerated(uint64(l))
 374         l = len(m.Error)
 375         n += 1 + l + sovGenerated(uint64(l))
 376         if len(m.Audiences) > 0 {
 377                 for _, s := range m.Audiences {
 378                         l = len(s)
 379                         n += 1 + l + sovGenerated(uint64(l))
 380                 }
 381         }
 382         return n
 383 }
 384
 385 func (m *UserInfo) Size() (n int) {
 386         var l int
 387         _ = l
 388         l = len(m.Username)
 389         n += 1 + l + sovGenerated(uint64(l))
 390         l = len(m.UID)
 391         n += 1 + l + sovGenerated(uint64(l))
 392         if len(m.Groups) > 0 {
 393                 for _, s := range m.Groups {
 394                         l = len(s)
 395                         n += 1 + l + sovGenerated(uint64(l))
 396                 }
 397         }
 398         if len(m.Extra) > 0 {
 399                 for k, v := range m.Extra {
 400                         _ = k
 401                         _ = v
 402                         l = v.Size()
 403                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
 404                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 405                 }
 406         }
 407         return n
 408 }
 409
 410 func sovGenerated(x uint64) (n int) {
 411         for {
 412                 n++
 413                 x >>= 7
 414                 if x == 0 {
 415                         break
 416                 }
 417         }
 418         return n
 419 }
 420 func sozGenerated(x uint64) (n int) {
 421         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 422 }
 423 func (this *TokenReview) String() string {
 424         if this == nil {
 425                 return "nil"
 426         }
 427         s := strings.Join([]string{`&TokenReview{`,
 428                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 429                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "TokenReviewSpec", "TokenReviewSpec", 1), `&`, ``, 1) + `,`,
 430                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "TokenReviewStatus", "TokenReviewStatus", 1), `&`, ``, 1) + `,`,
 431                 `}`,
 432         }, "")
 433         return s
 434 }
 435 func (this *TokenReviewSpec) String() string {
 436         if this == nil {
 437                 return "nil"
 438         }
 439         s := strings.Join([]string{`&TokenReviewSpec{`,
 440                 `Token:` + fmt.Sprintf("%v", this.Token) + `,`,
 441                 `Audiences:` + fmt.Sprintf("%v", this.Audiences) + `,`,
 442                 `}`,
 443         }, "")
 444         return s
 445 }
 446 func (this *TokenReviewStatus) String() string {
 447         if this == nil {
 448                 return "nil"
 449         }
 450         s := strings.Join([]string{`&TokenReviewStatus{`,
 451                 `Authenticated:` + fmt.Sprintf("%v", this.Authenticated) + `,`,
 452                 `User:` + strings.Replace(strings.Replace(this.User.String(), "UserInfo", "UserInfo", 1), `&`, ``, 1) + `,`,
 453                 `Error:` + fmt.Sprintf("%v", this.Error) + `,`,
 454                 `Audiences:` + fmt.Sprintf("%v", this.Audiences) + `,`,
 455                 `}`,
 456         }, "")
 457         return s
 458 }
 459 func (this *UserInfo) String() string {
 460         if this == nil {
 461                 return "nil"
 462         }
 463         keysForExtra := make([]string, 0, len(this.Extra))
 464         for k := range this.Extra {
 465                 keysForExtra = append(keysForExtra, k)
 466         }
 467         github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
 468         mapStringForExtra := "map[string]ExtraValue{"
 469         for _, k := range keysForExtra {
 470                 mapStringForExtra += fmt.Sprintf("%v: %v,", k, this.Extra[k])
 471         }
 472         mapStringForExtra += "}"
 473         s := strings.Join([]string{`&UserInfo{`,
 474                 `Username:` + fmt.Sprintf("%v", this.Username) + `,`,
 475                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
 476                 `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
 477                 `Extra:` + mapStringForExtra + `,`,
 478                 `}`,
 479         }, "")
 480         return s
 481 }
 482 func valueToStringGenerated(v interface{}) string {
 483         rv := reflect.ValueOf(v)
 484         if rv.IsNil() {
 485                 return "nil"
 486         }
 487         pv := reflect.Indirect(rv).Interface()
 488         return fmt.Sprintf("*%v", pv)
 489 }
 490 func (m *ExtraValue) Unmarshal(dAtA []byte) error {
 491         l := len(dAtA)
 492         iNdEx := 0
 493         for iNdEx < l {
 494                 preIndex := iNdEx
 495                 var wire uint64
 496                 for shift := uint(0); ; shift += 7 {
 497                         if shift >= 64 {
 498                                 return ErrIntOverflowGenerated
 499                         }
 500                         if iNdEx >= l {
 501                                 return io.ErrUnexpectedEOF
 502                         }
 503                         b := dAtA[iNdEx]
 504                         iNdEx++
 505                         wire |= (uint64(b) & 0x7F) << shift
 506                         if b < 0x80 {
 507                                 break
 508                         }
 509                 }
 510                 fieldNum := int32(wire >> 3)
 511                 wireType := int(wire & 0x7)
 512                 if wireType == 4 {
 513                         return fmt.Errorf("proto: ExtraValue: wiretype end group for non-group")
 514                 }
 515                 if fieldNum <= 0 {
 516                         return fmt.Errorf("proto: ExtraValue: illegal tag %d (wire type %d)", fieldNum, wire)
 517                 }
 518                 switch fieldNum {
 519                 case 1:
 520                         if wireType != 2 {
 521                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 522                         }
 523                         var stringLen uint64
 524                         for shift := uint(0); ; shift += 7 {
 525                                 if shift >= 64 {
 526                                         return ErrIntOverflowGenerated
 527                                 }
 528                                 if iNdEx >= l {
 529                                         return io.ErrUnexpectedEOF
 530                                 }
 531                                 b := dAtA[iNdEx]
 532                                 iNdEx++
 533                                 stringLen |= (uint64(b) & 0x7F) << shift
 534                                 if b < 0x80 {
 535                                         break
 536                                 }
 537                         }
 538                         intStringLen := int(stringLen)
 539                         if intStringLen < 0 {
 540                                 return ErrInvalidLengthGenerated
 541                         }
 542                         postIndex := iNdEx + intStringLen
 543                         if postIndex > l {
 544                                 return io.ErrUnexpectedEOF
 545                         }
 546                         *m = append(*m, string(dAtA[iNdEx:postIndex]))
 547                         iNdEx = postIndex
 548                 default:
 549                         iNdEx = preIndex
 550                         skippy, err := skipGenerated(dAtA[iNdEx:])
 551                         if err != nil {
 552                                 return err
 553                         }
 554                         if skippy < 0 {
 555                                 return ErrInvalidLengthGenerated
 556                         }
 557                         if (iNdEx + skippy) > l {
 558                                 return io.ErrUnexpectedEOF
 559                         }
 560                         iNdEx += skippy
 561                 }
 562         }
 563
 564         if iNdEx > l {
 565                 return io.ErrUnexpectedEOF
 566         }
 567         return nil
 568 }
 569 func (m *TokenReview) Unmarshal(dAtA []byte) error {
 570         l := len(dAtA)
 571         iNdEx := 0
 572         for iNdEx < l {
 573                 preIndex := iNdEx
 574                 var wire uint64
 575                 for shift := uint(0); ; shift += 7 {
 576                         if shift >= 64 {
 577                                 return ErrIntOverflowGenerated
 578                         }
 579                         if iNdEx >= l {
 580                                 return io.ErrUnexpectedEOF
 581                         }
 582                         b := dAtA[iNdEx]
 583                         iNdEx++
 584                         wire |= (uint64(b) & 0x7F) << shift
 585                         if b < 0x80 {
 586                                 break
 587                         }
 588                 }
 589                 fieldNum := int32(wire >> 3)
 590                 wireType := int(wire & 0x7)
 591                 if wireType == 4 {
 592                         return fmt.Errorf("proto: TokenReview: wiretype end group for non-group")
 593                 }
 594                 if fieldNum <= 0 {
 595                         return fmt.Errorf("proto: TokenReview: illegal tag %d (wire type %d)", fieldNum, wire)
 596                 }
 597                 switch fieldNum {
 598                 case 1:
 599                         if wireType != 2 {
 600                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 601                         }
 602                         var msglen int
 603                         for shift := uint(0); ; shift += 7 {
 604                                 if shift >= 64 {
 605                                         return ErrIntOverflowGenerated
 606                                 }
 607                                 if iNdEx >= l {
 608                                         return io.ErrUnexpectedEOF
 609                                 }
 610                                 b := dAtA[iNdEx]
 611                                 iNdEx++
 612                                 msglen |= (int(b) & 0x7F) << shift
 613                                 if b < 0x80 {
 614                                         break
 615                                 }
 616                         }
 617                         if msglen < 0 {
 618                                 return ErrInvalidLengthGenerated
 619                         }
 620                         postIndex := iNdEx + msglen
 621                         if postIndex > l {
 622                                 return io.ErrUnexpectedEOF
 623                         }
 624                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 625                                 return err
 626                         }
 627                         iNdEx = postIndex
 628                 case 2:
 629                         if wireType != 2 {
 630                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 631                         }
 632                         var msglen int
 633                         for shift := uint(0); ; shift += 7 {
 634                                 if shift >= 64 {
 635                                         return ErrIntOverflowGenerated
 636                                 }
 637                                 if iNdEx >= l {
 638                                         return io.ErrUnexpectedEOF
 639                                 }
 640                                 b := dAtA[iNdEx]
 641                                 iNdEx++
 642                                 msglen |= (int(b) & 0x7F) << shift
 643                                 if b < 0x80 {
 644                                         break
 645                                 }
 646                         }
 647                         if msglen < 0 {
 648                                 return ErrInvalidLengthGenerated
 649                         }
 650                         postIndex := iNdEx + msglen
 651                         if postIndex > l {
 652                                 return io.ErrUnexpectedEOF
 653                         }
 654                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 655                                 return err
 656                         }
 657                         iNdEx = postIndex
 658                 case 3:
 659                         if wireType != 2 {
 660                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 661                         }
 662                         var msglen int
 663                         for shift := uint(0); ; shift += 7 {
 664                                 if shift >= 64 {
 665                                         return ErrIntOverflowGenerated
 666                                 }
 667                                 if iNdEx >= l {
 668                                         return io.ErrUnexpectedEOF
 669                                 }
 670                                 b := dAtA[iNdEx]
 671                                 iNdEx++
 672                                 msglen |= (int(b) & 0x7F) << shift
 673                                 if b < 0x80 {
 674                                         break
 675                                 }
 676                         }
 677                         if msglen < 0 {
 678                                 return ErrInvalidLengthGenerated
 679                         }
 680                         postIndex := iNdEx + msglen
 681                         if postIndex > l {
 682                                 return io.ErrUnexpectedEOF
 683                         }
 684                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 685                                 return err
 686                         }
 687                         iNdEx = postIndex
 688                 default:
 689                         iNdEx = preIndex
 690                         skippy, err := skipGenerated(dAtA[iNdEx:])
 691                         if err != nil {
 692                                 return err
 693                         }
 694                         if skippy < 0 {
 695                                 return ErrInvalidLengthGenerated
 696                         }
 697                         if (iNdEx + skippy) > l {
 698                                 return io.ErrUnexpectedEOF
 699                         }
 700                         iNdEx += skippy
 701                 }
 702         }
 703
 704         if iNdEx > l {
 705                 return io.ErrUnexpectedEOF
 706         }
 707         return nil
 708 }
 709 func (m *TokenReviewSpec) Unmarshal(dAtA []byte) error {
 710         l := len(dAtA)
 711         iNdEx := 0
 712         for iNdEx < l {
 713                 preIndex := iNdEx
 714                 var wire uint64
 715                 for shift := uint(0); ; shift += 7 {
 716                         if shift >= 64 {
 717                                 return ErrIntOverflowGenerated
 718                         }
 719                         if iNdEx >= l {
 720                                 return io.ErrUnexpectedEOF
 721                         }
 722                         b := dAtA[iNdEx]
 723                         iNdEx++
 724                         wire |= (uint64(b) & 0x7F) << shift
 725                         if b < 0x80 {
 726                                 break
 727                         }
 728                 }
 729                 fieldNum := int32(wire >> 3)
 730                 wireType := int(wire & 0x7)
 731                 if wireType == 4 {
 732                         return fmt.Errorf("proto: TokenReviewSpec: wiretype end group for non-group")
 733                 }
 734                 if fieldNum <= 0 {
 735                         return fmt.Errorf("proto: TokenReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 736                 }
 737                 switch fieldNum {
 738                 case 1:
 739                         if wireType != 2 {
 740                                 return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
 741                         }
 742                         var stringLen uint64
 743                         for shift := uint(0); ; shift += 7 {
 744                                 if shift >= 64 {
 745                                         return ErrIntOverflowGenerated
 746                                 }
 747                                 if iNdEx >= l {
 748                                         return io.ErrUnexpectedEOF
 749                                 }
 750                                 b := dAtA[iNdEx]
 751                                 iNdEx++
 752                                 stringLen |= (uint64(b) & 0x7F) << shift
 753                                 if b < 0x80 {
 754                                         break
 755                                 }
 756                         }
 757                         intStringLen := int(stringLen)
 758                         if intStringLen < 0 {
 759                                 return ErrInvalidLengthGenerated
 760                         }
 761                         postIndex := iNdEx + intStringLen
 762                         if postIndex > l {
 763                                 return io.ErrUnexpectedEOF
 764                         }
 765                         m.Token = string(dAtA[iNdEx:postIndex])
 766                         iNdEx = postIndex
 767                 case 2:
 768                         if wireType != 2 {
 769                                 return fmt.Errorf("proto: wrong wireType = %d for field Audiences", wireType)
 770                         }
 771                         var stringLen uint64
 772                         for shift := uint(0); ; shift += 7 {
 773                                 if shift >= 64 {
 774                                         return ErrIntOverflowGenerated
 775                                 }
 776                                 if iNdEx >= l {
 777                                         return io.ErrUnexpectedEOF
 778                                 }
 779                                 b := dAtA[iNdEx]
 780                                 iNdEx++
 781                                 stringLen |= (uint64(b) & 0x7F) << shift
 782                                 if b < 0x80 {
 783                                         break
 784                                 }
 785                         }
 786                         intStringLen := int(stringLen)
 787                         if intStringLen < 0 {
 788                                 return ErrInvalidLengthGenerated
 789                         }
 790                         postIndex := iNdEx + intStringLen
 791                         if postIndex > l {
 792                                 return io.ErrUnexpectedEOF
 793                         }
 794                         m.Audiences = append(m.Audiences, string(dAtA[iNdEx:postIndex]))
 795                         iNdEx = postIndex
 796                 default:
 797                         iNdEx = preIndex
 798                         skippy, err := skipGenerated(dAtA[iNdEx:])
 799                         if err != nil {
 800                                 return err
 801                         }
 802                         if skippy < 0 {
 803                                 return ErrInvalidLengthGenerated
 804                         }
 805                         if (iNdEx + skippy) > l {
 806                                 return io.ErrUnexpectedEOF
 807                         }
 808                         iNdEx += skippy
 809                 }
 810         }
 811
 812         if iNdEx > l {
 813                 return io.ErrUnexpectedEOF
 814         }
 815         return nil
 816 }
 817 func (m *TokenReviewStatus) Unmarshal(dAtA []byte) error {
 818         l := len(dAtA)
 819         iNdEx := 0
 820         for iNdEx < l {
 821                 preIndex := iNdEx
 822                 var wire uint64
 823                 for shift := uint(0); ; shift += 7 {
 824                         if shift >= 64 {
 825                                 return ErrIntOverflowGenerated
 826                         }
 827                         if iNdEx >= l {
 828                                 return io.ErrUnexpectedEOF
 829                         }
 830                         b := dAtA[iNdEx]
 831                         iNdEx++
 832                         wire |= (uint64(b) & 0x7F) << shift
 833                         if b < 0x80 {
 834                                 break
 835                         }
 836                 }
 837                 fieldNum := int32(wire >> 3)
 838                 wireType := int(wire & 0x7)
 839                 if wireType == 4 {
 840                         return fmt.Errorf("proto: TokenReviewStatus: wiretype end group for non-group")
 841                 }
 842                 if fieldNum <= 0 {
 843                         return fmt.Errorf("proto: TokenReviewStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 844                 }
 845                 switch fieldNum {
 846                 case 1:
 847                         if wireType != 0 {
 848                                 return fmt.Errorf("proto: wrong wireType = %d for field Authenticated", wireType)
 849                         }
 850                         var v int
 851                         for shift := uint(0); ; shift += 7 {
 852                                 if shift >= 64 {
 853                                         return ErrIntOverflowGenerated
 854                                 }
 855                                 if iNdEx >= l {
 856                                         return io.ErrUnexpectedEOF
 857                                 }
 858                                 b := dAtA[iNdEx]
 859                                 iNdEx++
 860                                 v |= (int(b) & 0x7F) << shift
 861                                 if b < 0x80 {
 862                                         break
 863                                 }
 864                         }
 865                         m.Authenticated = bool(v != 0)
 866                 case 2:
 867                         if wireType != 2 {
 868                                 return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
 869                         }
 870                         var msglen int
 871                         for shift := uint(0); ; shift += 7 {
 872                                 if shift >= 64 {
 873                                         return ErrIntOverflowGenerated
 874                                 }
 875                                 if iNdEx >= l {
 876                                         return io.ErrUnexpectedEOF
 877                                 }
 878                                 b := dAtA[iNdEx]
 879                                 iNdEx++
 880                                 msglen |= (int(b) & 0x7F) << shift
 881                                 if b < 0x80 {
 882                                         break
 883                                 }
 884                         }
 885                         if msglen < 0 {
 886                                 return ErrInvalidLengthGenerated
 887                         }
 888                         postIndex := iNdEx + msglen
 889                         if postIndex > l {
 890                                 return io.ErrUnexpectedEOF
 891                         }
 892                         if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 893                                 return err
 894                         }
 895                         iNdEx = postIndex
 896                 case 3:
 897                         if wireType != 2 {
 898                                 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 899                         }
 900                         var stringLen uint64
 901                         for shift := uint(0); ; shift += 7 {
 902                                 if shift >= 64 {
 903                                         return ErrIntOverflowGenerated
 904                                 }
 905                                 if iNdEx >= l {
 906                                         return io.ErrUnexpectedEOF
 907                                 }
 908                                 b := dAtA[iNdEx]
 909                                 iNdEx++
 910                                 stringLen |= (uint64(b) & 0x7F) << shift
 911                                 if b < 0x80 {
 912                                         break
 913                                 }
 914                         }
 915                         intStringLen := int(stringLen)
 916                         if intStringLen < 0 {
 917                                 return ErrInvalidLengthGenerated
 918                         }
 919                         postIndex := iNdEx + intStringLen
 920                         if postIndex > l {
 921                                 return io.ErrUnexpectedEOF
 922                         }
 923                         m.Error = string(dAtA[iNdEx:postIndex])
 924                         iNdEx = postIndex
 925                 case 4:
 926                         if wireType != 2 {
 927                                 return fmt.Errorf("proto: wrong wireType = %d for field Audiences", wireType)
 928                         }
 929                         var stringLen uint64
 930                         for shift := uint(0); ; shift += 7 {
 931                                 if shift >= 64 {
 932                                         return ErrIntOverflowGenerated
 933                                 }
 934                                 if iNdEx >= l {
 935                                         return io.ErrUnexpectedEOF
 936                                 }
 937                                 b := dAtA[iNdEx]
 938                                 iNdEx++
 939                                 stringLen |= (uint64(b) & 0x7F) << shift
 940                                 if b < 0x80 {
 941                                         break
 942                                 }
 943                         }
 944                         intStringLen := int(stringLen)
 945                         if intStringLen < 0 {
 946                                 return ErrInvalidLengthGenerated
 947                         }
 948                         postIndex := iNdEx + intStringLen
 949                         if postIndex > l {
 950                                 return io.ErrUnexpectedEOF
 951                         }
 952                         m.Audiences = append(m.Audiences, string(dAtA[iNdEx:postIndex]))
 953                         iNdEx = postIndex
 954                 default:
 955                         iNdEx = preIndex
 956                         skippy, err := skipGenerated(dAtA[iNdEx:])
 957                         if err != nil {
 958                                 return err
 959                         }
 960                         if skippy < 0 {
 961                                 return ErrInvalidLengthGenerated
 962                         }
 963                         if (iNdEx + skippy) > l {
 964                                 return io.ErrUnexpectedEOF
 965                         }
 966                         iNdEx += skippy
 967                 }
 968         }
 969
 970         if iNdEx > l {
 971                 return io.ErrUnexpectedEOF
 972         }
 973         return nil
 974 }
 975 func (m *UserInfo) Unmarshal(dAtA []byte) error {
 976         l := len(dAtA)
 977         iNdEx := 0
 978         for iNdEx < l {
 979                 preIndex := iNdEx
 980                 var wire uint64
 981                 for shift := uint(0); ; shift += 7 {
 982                         if shift >= 64 {
 983                                 return ErrIntOverflowGenerated
 984                         }
 985                         if iNdEx >= l {
 986                                 return io.ErrUnexpectedEOF
 987                         }
 988                         b := dAtA[iNdEx]
 989                         iNdEx++
 990                         wire |= (uint64(b) & 0x7F) << shift
 991                         if b < 0x80 {
 992                                 break
 993                         }
 994                 }
 995                 fieldNum := int32(wire >> 3)
 996                 wireType := int(wire & 0x7)
 997                 if wireType == 4 {
 998                         return fmt.Errorf("proto: UserInfo: wiretype end group for non-group")
 999                 }
1000                 if fieldNum <= 0 {
1001                         return fmt.Errorf("proto: UserInfo: illegal tag %d (wire type %d)", fieldNum, wire)
1002                 }
1003                 switch fieldNum {
1004                 case 1:
1005                         if wireType != 2 {
1006                                 return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
1007                         }
1008                         var stringLen 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                                 stringLen |= (uint64(b) & 0x7F) << shift
1019                                 if b < 0x80 {
1020                                         break
1021                                 }
1022                         }
1023                         intStringLen := int(stringLen)
1024                         if intStringLen < 0 {
1025                                 return ErrInvalidLengthGenerated
1026                         }
1027                         postIndex := iNdEx + intStringLen
1028                         if postIndex > l {
1029                                 return io.ErrUnexpectedEOF
1030                         }
1031                         m.Username = string(dAtA[iNdEx:postIndex])
1032                         iNdEx = postIndex
1033                 case 2:
1034                         if wireType != 2 {
1035                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
1036                         }
1037                         var stringLen uint64
1038                         for shift := uint(0); ; shift += 7 {
1039                                 if shift >= 64 {
1040                                         return ErrIntOverflowGenerated
1041                                 }
1042                                 if iNdEx >= l {
1043                                         return io.ErrUnexpectedEOF
1044                                 }
1045                                 b := dAtA[iNdEx]
1046                                 iNdEx++
1047                                 stringLen |= (uint64(b) & 0x7F) << shift
1048                                 if b < 0x80 {
1049                                         break
1050                                 }
1051                         }
1052                         intStringLen := int(stringLen)
1053                         if intStringLen < 0 {
1054                                 return ErrInvalidLengthGenerated
1055                         }
1056                         postIndex := iNdEx + intStringLen
1057                         if postIndex > l {
1058                                 return io.ErrUnexpectedEOF
1059                         }
1060                         m.UID = string(dAtA[iNdEx:postIndex])
1061                         iNdEx = postIndex
1062                 case 3:
1063                         if wireType != 2 {
1064                                 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
1065                         }
1066                         var stringLen uint64
1067                         for shift := uint(0); ; shift += 7 {
1068                                 if shift >= 64 {
1069                                         return ErrIntOverflowGenerated
1070                                 }
1071                                 if iNdEx >= l {
1072                                         return io.ErrUnexpectedEOF
1073                                 }
1074                                 b := dAtA[iNdEx]
1075                                 iNdEx++
1076                                 stringLen |= (uint64(b) & 0x7F) << shift
1077                                 if b < 0x80 {
1078                                         break
1079                                 }
1080                         }
1081                         intStringLen := int(stringLen)
1082                         if intStringLen < 0 {
1083                                 return ErrInvalidLengthGenerated
1084                         }
1085                         postIndex := iNdEx + intStringLen
1086                         if postIndex > l {
1087                                 return io.ErrUnexpectedEOF
1088                         }
1089                         m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
1090                         iNdEx = postIndex
1091                 case 4:
1092                         if wireType != 2 {
1093                                 return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
1094                         }
1095                         var msglen int
1096                         for shift := uint(0); ; shift += 7 {
1097                                 if shift >= 64 {
1098                                         return ErrIntOverflowGenerated
1099                                 }
1100                                 if iNdEx >= l {
1101                                         return io.ErrUnexpectedEOF
1102                                 }
1103                                 b := dAtA[iNdEx]
1104                                 iNdEx++
1105                                 msglen |= (int(b) & 0x7F) << shift
1106                                 if b < 0x80 {
1107                                         break
1108                                 }
1109                         }
1110                         if msglen < 0 {
1111                                 return ErrInvalidLengthGenerated
1112                         }
1113                         postIndex := iNdEx + msglen
1114                         if postIndex > l {
1115                                 return io.ErrUnexpectedEOF
1116                         }
1117                         if m.Extra == nil {
1118                                 m.Extra = make(map[string]ExtraValue)
1119                         }
1120                         var mapkey string
1121                         mapvalue := &ExtraValue{}
1122                         for iNdEx < postIndex {
1123                                 entryPreIndex := iNdEx
1124                                 var wire uint64
1125                                 for shift := uint(0); ; shift += 7 {
1126                                         if shift >= 64 {
1127                                                 return ErrIntOverflowGenerated
1128                                         }
1129                                         if iNdEx >= l {
1130                                                 return io.ErrUnexpectedEOF
1131                                         }
1132                                         b := dAtA[iNdEx]
1133                                         iNdEx++
1134                                         wire |= (uint64(b) & 0x7F) << shift
1135                                         if b < 0x80 {
1136                                                 break
1137                                         }
1138                                 }
1139                                 fieldNum := int32(wire >> 3)
1140                                 if fieldNum == 1 {
1141                                         var stringLenmapkey uint64
1142                                         for shift := uint(0); ; shift += 7 {
1143                                                 if shift >= 64 {
1144                                                         return ErrIntOverflowGenerated
1145                                                 }
1146                                                 if iNdEx >= l {
1147                                                         return io.ErrUnexpectedEOF
1148                                                 }
1149                                                 b := dAtA[iNdEx]
1150                                                 iNdEx++
1151                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
1152                                                 if b < 0x80 {
1153                                                         break
1154                                                 }
1155                                         }
1156                                         intStringLenmapkey := int(stringLenmapkey)
1157                                         if intStringLenmapkey < 0 {
1158                                                 return ErrInvalidLengthGenerated
1159                                         }
1160                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
1161                                         if postStringIndexmapkey > l {
1162                                                 return io.ErrUnexpectedEOF
1163                                         }
1164                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1165                                         iNdEx = postStringIndexmapkey
1166                                 } else if fieldNum == 2 {
1167                                         var mapmsglen int
1168                                         for shift := uint(0); ; shift += 7 {
1169                                                 if shift >= 64 {
1170                                                         return ErrIntOverflowGenerated
1171                                                 }
1172                                                 if iNdEx >= l {
1173                                                         return io.ErrUnexpectedEOF
1174                                                 }
1175                                                 b := dAtA[iNdEx]
1176                                                 iNdEx++
1177                                                 mapmsglen |= (int(b) & 0x7F) << shift
1178                                                 if b < 0x80 {
1179                                                         break
1180                                                 }
1181                                         }
1182                                         if mapmsglen < 0 {
1183                                                 return ErrInvalidLengthGenerated
1184                                         }
1185                                         postmsgIndex := iNdEx + mapmsglen
1186                                         if mapmsglen < 0 {
1187                                                 return ErrInvalidLengthGenerated
1188                                         }
1189                                         if postmsgIndex > l {
1190                                                 return io.ErrUnexpectedEOF
1191                                         }
1192                                         mapvalue = &ExtraValue{}
1193                                         if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
1194                                                 return err
1195                                         }
1196                                         iNdEx = postmsgIndex
1197                                 } else {
1198                                         iNdEx = entryPreIndex
1199                                         skippy, err := skipGenerated(dAtA[iNdEx:])
1200                                         if err != nil {
1201                                                 return err
1202                                         }
1203                                         if skippy < 0 {
1204                                                 return ErrInvalidLengthGenerated
1205                                         }
1206                                         if (iNdEx + skippy) > postIndex {
1207                                                 return io.ErrUnexpectedEOF
1208                                         }
1209                                         iNdEx += skippy
1210                                 }
1211                         }
1212                         m.Extra[mapkey] = *mapvalue
1213                         iNdEx = postIndex
1214                 default:
1215                         iNdEx = preIndex
1216                         skippy, err := skipGenerated(dAtA[iNdEx:])
1217                         if err != nil {
1218                                 return err
1219                         }
1220                         if skippy < 0 {
1221                                 return ErrInvalidLengthGenerated
1222                         }
1223                         if (iNdEx + skippy) > l {
1224                                 return io.ErrUnexpectedEOF
1225                         }
1226                         iNdEx += skippy
1227                 }
1228         }
1229
1230         if iNdEx > l {
1231                 return io.ErrUnexpectedEOF
1232         }
1233         return nil
1234 }
1235 func skipGenerated(dAtA []byte) (n int, err error) {
1236         l := len(dAtA)
1237         iNdEx := 0
1238         for iNdEx < l {
1239                 var wire uint64
1240                 for shift := uint(0); ; shift += 7 {
1241                         if shift >= 64 {
1242                                 return 0, ErrIntOverflowGenerated
1243                         }
1244                         if iNdEx >= l {
1245                                 return 0, io.ErrUnexpectedEOF
1246                         }
1247                         b := dAtA[iNdEx]
1248                         iNdEx++
1249                         wire |= (uint64(b) & 0x7F) << shift
1250                         if b < 0x80 {
1251                                 break
1252                         }
1253                 }
1254                 wireType := int(wire & 0x7)
1255                 switch wireType {
1256                 case 0:
1257                         for shift := uint(0); ; shift += 7 {
1258                                 if shift >= 64 {
1259                                         return 0, ErrIntOverflowGenerated
1260                                 }
1261                                 if iNdEx >= l {
1262                                         return 0, io.ErrUnexpectedEOF
1263                                 }
1264                                 iNdEx++
1265                                 if dAtA[iNdEx-1] < 0x80 {
1266                                         break
1267                                 }
1268                         }
1269                         return iNdEx, nil
1270                 case 1:
1271                         iNdEx += 8
1272                         return iNdEx, nil
1273                 case 2:
1274                         var length int
1275                         for shift := uint(0); ; shift += 7 {
1276                                 if shift >= 64 {
1277                                         return 0, ErrIntOverflowGenerated
1278                                 }
1279                                 if iNdEx >= l {
1280                                         return 0, io.ErrUnexpectedEOF
1281                                 }
1282                                 b := dAtA[iNdEx]
1283                                 iNdEx++
1284                                 length |= (int(b) & 0x7F) << shift
1285                                 if b < 0x80 {
1286                                         break
1287                                 }
1288                         }
1289                         iNdEx += length
1290                         if length < 0 {
1291                                 return 0, ErrInvalidLengthGenerated
1292                         }
1293                         return iNdEx, nil
1294                 case 3:
1295                         for {
1296                                 var innerWire uint64
1297                                 var start int = iNdEx
1298                                 for shift := uint(0); ; shift += 7 {
1299                                         if shift >= 64 {
1300                                                 return 0, ErrIntOverflowGenerated
1301                                         }
1302                                         if iNdEx >= l {
1303                                                 return 0, io.ErrUnexpectedEOF
1304                                         }
1305                                         b := dAtA[iNdEx]
1306                                         iNdEx++
1307                                         innerWire |= (uint64(b) & 0x7F) << shift
1308                                         if b < 0x80 {
1309                                                 break
1310                                         }
1311                                 }
1312                                 innerWireType := int(innerWire & 0x7)
1313                                 if innerWireType == 4 {
1314                                         break
1315                                 }
1316                                 next, err := skipGenerated(dAtA[start:])
1317                                 if err != nil {
1318                                         return 0, err
1319                                 }
1320                                 iNdEx = start + next
1321                         }
1322                         return iNdEx, nil
1323                 case 4:
1324                         return iNdEx, nil
1325                 case 5:
1326                         iNdEx += 4
1327                         return iNdEx, nil
1328                 default:
1329                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1330                 }
1331         }
1332         panic("unreachable")
1333 }
1334
1335 var (
1336         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1337         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
1338 )
1339
1340 func init() {
1341         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/authentication/v1beta1/generated.proto", fileDescriptorGenerated)
1342 }
1343
1344 var fileDescriptorGenerated = []byte{
1345         // 663 bytes of a gzipped FileDescriptorProto
1346         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xcd, 0x4e, 0x14, 0x4d,
1347         0x14, 0xed, 0x9e, 0x1f, 0xbe, 0x99, 0x9a, 0x6f, 0x14, 0x2b, 0x31, 0x99, 0x4c, 0x62, 0x0f, 0x8e,
1348         0x1b, 0x12, 0xa4, 0x5a, 0x08, 0x41, 0x82, 0x2b, 0x5a, 0x89, 0xc1, 0x84, 0x98, 0x94, 0xe0, 0x42,
1349         0x5d, 0x58, 0xd3, 0x73, 0xe9, 0x69, 0xc7, 0xfe, 0x49, 0x55, 0xf5, 0x28, 0x3b, 0x1e, 0xc1, 0xa5,
1350         0x4b, 0x13, 0x9f, 0xc4, 0x1d, 0x4b, 0x96, 0x2c, 0xcc, 0x44, 0xda, 0x27, 0xf0, 0x0d, 0x4c, 0x55,
1351         0x17, 0xcc, 0x00, 0x31, 0xc0, 0xae, 0xeb, 0xdc, 0x7b, 0xce, 0x3d, 0xf7, 0x54, 0x17, 0x7a, 0x31,
1352         0x5c, 0x13, 0x24, 0x4c, 0xdc, 0x61, 0xd6, 0x03, 0x1e, 0x83, 0x04, 0xe1, 0x8e, 0x20, 0xee, 0x27,
1353         0xdc, 0x35, 0x05, 0x96, 0x86, 0x2e, 0xcb, 0xe4, 0x00, 0x62, 0x19, 0xfa, 0x4c, 0x86, 0x49, 0xec,
1354         0x8e, 0x96, 0x7a, 0x20, 0xd9, 0x92, 0x1b, 0x40, 0x0c, 0x9c, 0x49, 0xe8, 0x93, 0x94, 0x27, 0x32,
1355         0xc1, 0xf7, 0x0b, 0x0a, 0x61, 0x69, 0x48, 0xce, 0x53, 0x88, 0xa1, 0xb4, 0x17, 0x83, 0x50, 0x0e,
1356         0xb2, 0x1e, 0xf1, 0x93, 0xc8, 0x0d, 0x92, 0x20, 0x71, 0x35, 0xb3, 0x97, 0xed, 0xe9, 0x93, 0x3e,
1357         0xe8, 0xaf, 0x42, 0xb1, 0xbd, 0x32, 0x31, 0x11, 0x31, 0x7f, 0x10, 0xc6, 0xc0, 0xf7, 0xdd, 0x74,
1358         0x18, 0x28, 0x40, 0xb8, 0x11, 0x48, 0xe6, 0x8e, 0x2e, 0xf9, 0x68, 0xbb, 0xff, 0x62, 0xf1, 0x2c,
1359         0x96, 0x61, 0x04, 0x97, 0x08, 0xab, 0x57, 0x11, 0x84, 0x3f, 0x80, 0x88, 0x5d, 0xe4, 0x75, 0x1f,
1360         0x23, 0xb4, 0xf9, 0x59, 0x72, 0xf6, 0x9a, 0x7d, 0xcc, 0x00, 0x77, 0x50, 0x35, 0x94, 0x10, 0x89,
1361         0x96, 0x3d, 0x57, 0x9e, 0xaf, 0x7b, 0xf5, 0x7c, 0xdc, 0xa9, 0x6e, 0x29, 0x80, 0x16, 0xf8, 0x7a,
1362         0xed, 0xeb, 0xb7, 0x8e, 0x75, 0xf0, 0x73, 0xce, 0xea, 0x7e, 0x2f, 0xa1, 0xc6, 0x4e, 0x32, 0x84,
1363         0x98, 0xc2, 0x28, 0x84, 0x4f, 0xf8, 0x3d, 0xaa, 0xa9, 0x65, 0xfa, 0x4c, 0xb2, 0x96, 0x3d, 0x67,
1364         0xcf, 0x37, 0x96, 0x1f, 0x91, 0x49, 0x98, 0x67, 0x9e, 0x48, 0x3a, 0x0c, 0x14, 0x20, 0x88, 0xea,
1365         0x26, 0xa3, 0x25, 0xf2, 0xb2, 0xf7, 0x01, 0x7c, 0xb9, 0x0d, 0x92, 0x79, 0xf8, 0x70, 0xdc, 0xb1,
1366         0xf2, 0x71, 0x07, 0x4d, 0x30, 0x7a, 0xa6, 0x8a, 0x77, 0x50, 0x45, 0xa4, 0xe0, 0xb7, 0x4a, 0x5a,
1367         0x7d, 0x99, 0x5c, 0x79, 0x55, 0x64, 0xca, 0xdf, 0xab, 0x14, 0x7c, 0xef, 0x7f, 0xa3, 0x5f, 0x51,
1368         0x27, 0xaa, 0xd5, 0xf0, 0x3b, 0x34, 0x23, 0x24, 0x93, 0x99, 0x68, 0x95, 0xb5, 0xee, 0xca, 0x0d,
1369         0x75, 0x35, 0xd7, 0xbb, 0x65, 0x94, 0x67, 0x8a, 0x33, 0x35, 0x9a, 0x5d, 0x1f, 0xdd, 0xbe, 0x60,
1370         0x02, 0x3f, 0x40, 0x55, 0xa9, 0x20, 0x9d, 0x52, 0xdd, 0x6b, 0x1a, 0x66, 0xb5, 0xe8, 0x2b, 0x6a,
1371         0x78, 0x01, 0xd5, 0x59, 0xd6, 0x0f, 0x21, 0xf6, 0x41, 0xb4, 0x4a, 0xfa, 0x32, 0x9a, 0xf9, 0xb8,
1372         0x53, 0xdf, 0x38, 0x05, 0xe9, 0xa4, 0xde, 0xfd, 0x63, 0xa3, 0x3b, 0x97, 0x2c, 0xe1, 0x27, 0xa8,
1373         0x39, 0x65, 0x1f, 0xfa, 0x7a, 0x5e, 0xcd, 0xbb, 0x6b, 0xe6, 0x35, 0x37, 0xa6, 0x8b, 0xf4, 0x7c,
1374         0x2f, 0xde, 0x46, 0x95, 0x4c, 0x00, 0x37, 0x59, 0x2f, 0x5c, 0x23, 0x93, 0x5d, 0x01, 0x7c, 0x2b,
1375         0xde, 0x4b, 0x26, 0x21, 0x2b, 0x84, 0x6a, 0x19, 0xb5, 0x33, 0x70, 0x9e, 0x70, 0x9d, 0xf1, 0xd4,
1376         0xce, 0x9b, 0x0a, 0xa4, 0x45, 0xed, 0xfc, 0xce, 0x95, 0x2b, 0x76, 0xfe, 0x51, 0x42, 0xb5, 0xd3,
1377         0x91, 0xf8, 0x21, 0xaa, 0xa9, 0x31, 0x31, 0x8b, 0xc0, 0xa4, 0x3a, 0x6b, 0x26, 0xe8, 0x1e, 0x85,
1378         0xd3, 0xb3, 0x0e, 0x7c, 0x0f, 0x95, 0xb3, 0xb0, 0xaf, 0x57, 0xab, 0x7b, 0x0d, 0xd3, 0x58, 0xde,
1379         0xdd, 0x7a, 0x46, 0x15, 0x8e, 0xbb, 0x68, 0x26, 0xe0, 0x49, 0x96, 0xaa, 0x1f, 0x42, 0x79, 0x40,
1380         0xea, 0x5a, 0x9f, 0x6b, 0x84, 0x9a, 0x0a, 0x7e, 0x8b, 0xaa, 0xa0, 0x5e, 0x8d, 0xb6, 0xd9, 0x58,
1381         0x5e, 0xbd, 0x41, 0x3e, 0x44, 0x3f, 0xb7, 0xcd, 0x58, 0xf2, 0xfd, 0xa9, 0x1c, 0x14, 0x46, 0x0b,
1382         0xcd, 0x76, 0x60, 0x9e, 0xa4, 0xee, 0xc1, 0xb3, 0xa8, 0x3c, 0x84, 0xfd, 0x62, 0x2d, 0xaa, 0x3e,
1383         0xf1, 0x53, 0x54, 0x1d, 0xa9, 0xd7, 0x6a, 0x2e, 0x67, 0xf1, 0x1a, 0xc3, 0x27, 0x4f, 0x9c, 0x16,
1384         0xdc, 0xf5, 0xd2, 0x9a, 0xed, 0x2d, 0x1e, 0x9e, 0x38, 0xd6, 0xd1, 0x89, 0x63, 0x1d, 0x9f, 0x38,
1385         0xd6, 0x41, 0xee, 0xd8, 0x87, 0xb9, 0x63, 0x1f, 0xe5, 0x8e, 0x7d, 0x9c, 0x3b, 0xf6, 0xaf, 0xdc,
1386         0xb1, 0xbf, 0xfc, 0x76, 0xac, 0x37, 0xff, 0x19, 0x91, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf7,
1387         0xd6, 0x32, 0x28, 0x68, 0x05, 0x00, 0x00,
1388 }