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