cmd/bpa-operator/vendor/k8s.io/api/admissionregistration/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/admissionregistration/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/admissionregistration/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 MutatingWebhookConfiguration
  28                 MutatingWebhookConfigurationList
  29                 Rule
  30                 RuleWithOperations
  31                 ServiceReference
  32                 ValidatingWebhookConfiguration
  33                 ValidatingWebhookConfigurationList
  34                 Webhook
  35                 WebhookClientConfig
  36 */
  37 package v1beta1
  38
  39 import proto "github.com/gogo/protobuf/proto"
  40 import fmt "fmt"
  41 import math "math"
  42
  43 import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  44
  45 import strings "strings"
  46 import reflect "reflect"
  47
  48 import io "io"
  49
  50 // Reference imports to suppress errors if they are not otherwise used.
  51 var _ = proto.Marshal
  52 var _ = fmt.Errorf
  53 var _ = math.Inf
  54
  55 // This is a compile-time assertion to ensure that this generated file
  56 // is compatible with the proto package it is being compiled against.
  57 // A compilation error at this line likely means your copy of the
  58 // proto package needs to be updated.
  59 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  60
  61 func (m *MutatingWebhookConfiguration) Reset()      { *m = MutatingWebhookConfiguration{} }
  62 func (*MutatingWebhookConfiguration) ProtoMessage() {}
  63 func (*MutatingWebhookConfiguration) Descriptor() ([]byte, []int) {
  64         return fileDescriptorGenerated, []int{0}
  65 }
  66
  67 func (m *MutatingWebhookConfigurationList) Reset()      { *m = MutatingWebhookConfigurationList{} }
  68 func (*MutatingWebhookConfigurationList) ProtoMessage() {}
  69 func (*MutatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
  70         return fileDescriptorGenerated, []int{1}
  71 }
  72
  73 func (m *Rule) Reset()                    { *m = Rule{} }
  74 func (*Rule) ProtoMessage()               {}
  75 func (*Rule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  76
  77 func (m *RuleWithOperations) Reset()                    { *m = RuleWithOperations{} }
  78 func (*RuleWithOperations) ProtoMessage()               {}
  79 func (*RuleWithOperations) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
  80
  81 func (m *ServiceReference) Reset()                    { *m = ServiceReference{} }
  82 func (*ServiceReference) ProtoMessage()               {}
  83 func (*ServiceReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
  84
  85 func (m *ValidatingWebhookConfiguration) Reset()      { *m = ValidatingWebhookConfiguration{} }
  86 func (*ValidatingWebhookConfiguration) ProtoMessage() {}
  87 func (*ValidatingWebhookConfiguration) Descriptor() ([]byte, []int) {
  88         return fileDescriptorGenerated, []int{5}
  89 }
  90
  91 func (m *ValidatingWebhookConfigurationList) Reset()      { *m = ValidatingWebhookConfigurationList{} }
  92 func (*ValidatingWebhookConfigurationList) ProtoMessage() {}
  93 func (*ValidatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
  94         return fileDescriptorGenerated, []int{6}
  95 }
  96
  97 func (m *Webhook) Reset()                    { *m = Webhook{} }
  98 func (*Webhook) ProtoMessage()               {}
  99 func (*Webhook) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
 100
 101 func (m *WebhookClientConfig) Reset()                    { *m = WebhookClientConfig{} }
 102 func (*WebhookClientConfig) ProtoMessage()               {}
 103 func (*WebhookClientConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
 104
 105 func init() {
 106         proto.RegisterType((*MutatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhookConfiguration")
 107         proto.RegisterType((*MutatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhookConfigurationList")
 108         proto.RegisterType((*Rule)(nil), "k8s.io.api.admissionregistration.v1beta1.Rule")
 109         proto.RegisterType((*RuleWithOperations)(nil), "k8s.io.api.admissionregistration.v1beta1.RuleWithOperations")
 110         proto.RegisterType((*ServiceReference)(nil), "k8s.io.api.admissionregistration.v1beta1.ServiceReference")
 111         proto.RegisterType((*ValidatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhookConfiguration")
 112         proto.RegisterType((*ValidatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhookConfigurationList")
 113         proto.RegisterType((*Webhook)(nil), "k8s.io.api.admissionregistration.v1beta1.Webhook")
 114         proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.api.admissionregistration.v1beta1.WebhookClientConfig")
 115 }
 116 func (m *MutatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
 117         size := m.Size()
 118         dAtA = make([]byte, size)
 119         n, err := m.MarshalTo(dAtA)
 120         if err != nil {
 121                 return nil, err
 122         }
 123         return dAtA[:n], nil
 124 }
 125
 126 func (m *MutatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
 127         var i int
 128         _ = i
 129         var l int
 130         _ = l
 131         dAtA[i] = 0xa
 132         i++
 133         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 134         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 135         if err != nil {
 136                 return 0, err
 137         }
 138         i += n1
 139         if len(m.Webhooks) > 0 {
 140                 for _, msg := range m.Webhooks {
 141                         dAtA[i] = 0x12
 142                         i++
 143                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 144                         n, err := msg.MarshalTo(dAtA[i:])
 145                         if err != nil {
 146                                 return 0, err
 147                         }
 148                         i += n
 149                 }
 150         }
 151         return i, nil
 152 }
 153
 154 func (m *MutatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
 155         size := m.Size()
 156         dAtA = make([]byte, size)
 157         n, err := m.MarshalTo(dAtA)
 158         if err != nil {
 159                 return nil, err
 160         }
 161         return dAtA[:n], nil
 162 }
 163
 164 func (m *MutatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
 165         var i int
 166         _ = i
 167         var l int
 168         _ = l
 169         dAtA[i] = 0xa
 170         i++
 171         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 172         n2, err := m.ListMeta.MarshalTo(dAtA[i:])
 173         if err != nil {
 174                 return 0, err
 175         }
 176         i += n2
 177         if len(m.Items) > 0 {
 178                 for _, msg := range m.Items {
 179                         dAtA[i] = 0x12
 180                         i++
 181                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 182                         n, err := msg.MarshalTo(dAtA[i:])
 183                         if err != nil {
 184                                 return 0, err
 185                         }
 186                         i += n
 187                 }
 188         }
 189         return i, nil
 190 }
 191
 192 func (m *Rule) Marshal() (dAtA []byte, err error) {
 193         size := m.Size()
 194         dAtA = make([]byte, size)
 195         n, err := m.MarshalTo(dAtA)
 196         if err != nil {
 197                 return nil, err
 198         }
 199         return dAtA[:n], nil
 200 }
 201
 202 func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
 203         var i int
 204         _ = i
 205         var l int
 206         _ = l
 207         if len(m.APIGroups) > 0 {
 208                 for _, s := range m.APIGroups {
 209                         dAtA[i] = 0xa
 210                         i++
 211                         l = len(s)
 212                         for l >= 1<<7 {
 213                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 214                                 l >>= 7
 215                                 i++
 216                         }
 217                         dAtA[i] = uint8(l)
 218                         i++
 219                         i += copy(dAtA[i:], s)
 220                 }
 221         }
 222         if len(m.APIVersions) > 0 {
 223                 for _, s := range m.APIVersions {
 224                         dAtA[i] = 0x12
 225                         i++
 226                         l = len(s)
 227                         for l >= 1<<7 {
 228                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 229                                 l >>= 7
 230                                 i++
 231                         }
 232                         dAtA[i] = uint8(l)
 233                         i++
 234                         i += copy(dAtA[i:], s)
 235                 }
 236         }
 237         if len(m.Resources) > 0 {
 238                 for _, s := range m.Resources {
 239                         dAtA[i] = 0x1a
 240                         i++
 241                         l = len(s)
 242                         for l >= 1<<7 {
 243                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 244                                 l >>= 7
 245                                 i++
 246                         }
 247                         dAtA[i] = uint8(l)
 248                         i++
 249                         i += copy(dAtA[i:], s)
 250                 }
 251         }
 252         return i, nil
 253 }
 254
 255 func (m *RuleWithOperations) Marshal() (dAtA []byte, err error) {
 256         size := m.Size()
 257         dAtA = make([]byte, size)
 258         n, err := m.MarshalTo(dAtA)
 259         if err != nil {
 260                 return nil, err
 261         }
 262         return dAtA[:n], nil
 263 }
 264
 265 func (m *RuleWithOperations) MarshalTo(dAtA []byte) (int, error) {
 266         var i int
 267         _ = i
 268         var l int
 269         _ = l
 270         if len(m.Operations) > 0 {
 271                 for _, s := range m.Operations {
 272                         dAtA[i] = 0xa
 273                         i++
 274                         l = len(s)
 275                         for l >= 1<<7 {
 276                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 277                                 l >>= 7
 278                                 i++
 279                         }
 280                         dAtA[i] = uint8(l)
 281                         i++
 282                         i += copy(dAtA[i:], s)
 283                 }
 284         }
 285         dAtA[i] = 0x12
 286         i++
 287         i = encodeVarintGenerated(dAtA, i, uint64(m.Rule.Size()))
 288         n3, err := m.Rule.MarshalTo(dAtA[i:])
 289         if err != nil {
 290                 return 0, err
 291         }
 292         i += n3
 293         return i, nil
 294 }
 295
 296 func (m *ServiceReference) Marshal() (dAtA []byte, err error) {
 297         size := m.Size()
 298         dAtA = make([]byte, size)
 299         n, err := m.MarshalTo(dAtA)
 300         if err != nil {
 301                 return nil, err
 302         }
 303         return dAtA[:n], nil
 304 }
 305
 306 func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
 307         var i int
 308         _ = i
 309         var l int
 310         _ = l
 311         dAtA[i] = 0xa
 312         i++
 313         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
 314         i += copy(dAtA[i:], m.Namespace)
 315         dAtA[i] = 0x12
 316         i++
 317         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 318         i += copy(dAtA[i:], m.Name)
 319         if m.Path != nil {
 320                 dAtA[i] = 0x1a
 321                 i++
 322                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Path)))
 323                 i += copy(dAtA[i:], *m.Path)
 324         }
 325         return i, nil
 326 }
 327
 328 func (m *ValidatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
 329         size := m.Size()
 330         dAtA = make([]byte, size)
 331         n, err := m.MarshalTo(dAtA)
 332         if err != nil {
 333                 return nil, err
 334         }
 335         return dAtA[:n], nil
 336 }
 337
 338 func (m *ValidatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
 339         var i int
 340         _ = i
 341         var l int
 342         _ = l
 343         dAtA[i] = 0xa
 344         i++
 345         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 346         n4, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 347         if err != nil {
 348                 return 0, err
 349         }
 350         i += n4
 351         if len(m.Webhooks) > 0 {
 352                 for _, msg := range m.Webhooks {
 353                         dAtA[i] = 0x12
 354                         i++
 355                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 356                         n, err := msg.MarshalTo(dAtA[i:])
 357                         if err != nil {
 358                                 return 0, err
 359                         }
 360                         i += n
 361                 }
 362         }
 363         return i, nil
 364 }
 365
 366 func (m *ValidatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
 367         size := m.Size()
 368         dAtA = make([]byte, size)
 369         n, err := m.MarshalTo(dAtA)
 370         if err != nil {
 371                 return nil, err
 372         }
 373         return dAtA[:n], nil
 374 }
 375
 376 func (m *ValidatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
 377         var i int
 378         _ = i
 379         var l int
 380         _ = l
 381         dAtA[i] = 0xa
 382         i++
 383         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 384         n5, err := m.ListMeta.MarshalTo(dAtA[i:])
 385         if err != nil {
 386                 return 0, err
 387         }
 388         i += n5
 389         if len(m.Items) > 0 {
 390                 for _, msg := range m.Items {
 391                         dAtA[i] = 0x12
 392                         i++
 393                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 394                         n, err := msg.MarshalTo(dAtA[i:])
 395                         if err != nil {
 396                                 return 0, err
 397                         }
 398                         i += n
 399                 }
 400         }
 401         return i, nil
 402 }
 403
 404 func (m *Webhook) Marshal() (dAtA []byte, err error) {
 405         size := m.Size()
 406         dAtA = make([]byte, size)
 407         n, err := m.MarshalTo(dAtA)
 408         if err != nil {
 409                 return nil, err
 410         }
 411         return dAtA[:n], nil
 412 }
 413
 414 func (m *Webhook) MarshalTo(dAtA []byte) (int, error) {
 415         var i int
 416         _ = i
 417         var l int
 418         _ = l
 419         dAtA[i] = 0xa
 420         i++
 421         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 422         i += copy(dAtA[i:], m.Name)
 423         dAtA[i] = 0x12
 424         i++
 425         i = encodeVarintGenerated(dAtA, i, uint64(m.ClientConfig.Size()))
 426         n6, err := m.ClientConfig.MarshalTo(dAtA[i:])
 427         if err != nil {
 428                 return 0, err
 429         }
 430         i += n6
 431         if len(m.Rules) > 0 {
 432                 for _, msg := range m.Rules {
 433                         dAtA[i] = 0x1a
 434                         i++
 435                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 436                         n, err := msg.MarshalTo(dAtA[i:])
 437                         if err != nil {
 438                                 return 0, err
 439                         }
 440                         i += n
 441                 }
 442         }
 443         if m.FailurePolicy != nil {
 444                 dAtA[i] = 0x22
 445                 i++
 446                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
 447                 i += copy(dAtA[i:], *m.FailurePolicy)
 448         }
 449         if m.NamespaceSelector != nil {
 450                 dAtA[i] = 0x2a
 451                 i++
 452                 i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
 453                 n7, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
 454                 if err != nil {
 455                         return 0, err
 456                 }
 457                 i += n7
 458         }
 459         if m.SideEffects != nil {
 460                 dAtA[i] = 0x32
 461                 i++
 462                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SideEffects)))
 463                 i += copy(dAtA[i:], *m.SideEffects)
 464         }
 465         return i, nil
 466 }
 467
 468 func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) {
 469         size := m.Size()
 470         dAtA = make([]byte, size)
 471         n, err := m.MarshalTo(dAtA)
 472         if err != nil {
 473                 return nil, err
 474         }
 475         return dAtA[:n], nil
 476 }
 477
 478 func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
 479         var i int
 480         _ = i
 481         var l int
 482         _ = l
 483         if m.Service != nil {
 484                 dAtA[i] = 0xa
 485                 i++
 486                 i = encodeVarintGenerated(dAtA, i, uint64(m.Service.Size()))
 487                 n8, err := m.Service.MarshalTo(dAtA[i:])
 488                 if err != nil {
 489                         return 0, err
 490                 }
 491                 i += n8
 492         }
 493         if m.CABundle != nil {
 494                 dAtA[i] = 0x12
 495                 i++
 496                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CABundle)))
 497                 i += copy(dAtA[i:], m.CABundle)
 498         }
 499         if m.URL != nil {
 500                 dAtA[i] = 0x1a
 501                 i++
 502                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.URL)))
 503                 i += copy(dAtA[i:], *m.URL)
 504         }
 505         return i, nil
 506 }
 507
 508 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 509         for v >= 1<<7 {
 510                 dAtA[offset] = uint8(v&0x7f | 0x80)
 511                 v >>= 7
 512                 offset++
 513         }
 514         dAtA[offset] = uint8(v)
 515         return offset + 1
 516 }
 517 func (m *MutatingWebhookConfiguration) Size() (n int) {
 518         var l int
 519         _ = l
 520         l = m.ObjectMeta.Size()
 521         n += 1 + l + sovGenerated(uint64(l))
 522         if len(m.Webhooks) > 0 {
 523                 for _, e := range m.Webhooks {
 524                         l = e.Size()
 525                         n += 1 + l + sovGenerated(uint64(l))
 526                 }
 527         }
 528         return n
 529 }
 530
 531 func (m *MutatingWebhookConfigurationList) Size() (n int) {
 532         var l int
 533         _ = l
 534         l = m.ListMeta.Size()
 535         n += 1 + l + sovGenerated(uint64(l))
 536         if len(m.Items) > 0 {
 537                 for _, e := range m.Items {
 538                         l = e.Size()
 539                         n += 1 + l + sovGenerated(uint64(l))
 540                 }
 541         }
 542         return n
 543 }
 544
 545 func (m *Rule) Size() (n int) {
 546         var l int
 547         _ = l
 548         if len(m.APIGroups) > 0 {
 549                 for _, s := range m.APIGroups {
 550                         l = len(s)
 551                         n += 1 + l + sovGenerated(uint64(l))
 552                 }
 553         }
 554         if len(m.APIVersions) > 0 {
 555                 for _, s := range m.APIVersions {
 556                         l = len(s)
 557                         n += 1 + l + sovGenerated(uint64(l))
 558                 }
 559         }
 560         if len(m.Resources) > 0 {
 561                 for _, s := range m.Resources {
 562                         l = len(s)
 563                         n += 1 + l + sovGenerated(uint64(l))
 564                 }
 565         }
 566         return n
 567 }
 568
 569 func (m *RuleWithOperations) Size() (n int) {
 570         var l int
 571         _ = l
 572         if len(m.Operations) > 0 {
 573                 for _, s := range m.Operations {
 574                         l = len(s)
 575                         n += 1 + l + sovGenerated(uint64(l))
 576                 }
 577         }
 578         l = m.Rule.Size()
 579         n += 1 + l + sovGenerated(uint64(l))
 580         return n
 581 }
 582
 583 func (m *ServiceReference) Size() (n int) {
 584         var l int
 585         _ = l
 586         l = len(m.Namespace)
 587         n += 1 + l + sovGenerated(uint64(l))
 588         l = len(m.Name)
 589         n += 1 + l + sovGenerated(uint64(l))
 590         if m.Path != nil {
 591                 l = len(*m.Path)
 592                 n += 1 + l + sovGenerated(uint64(l))
 593         }
 594         return n
 595 }
 596
 597 func (m *ValidatingWebhookConfiguration) Size() (n int) {
 598         var l int
 599         _ = l
 600         l = m.ObjectMeta.Size()
 601         n += 1 + l + sovGenerated(uint64(l))
 602         if len(m.Webhooks) > 0 {
 603                 for _, e := range m.Webhooks {
 604                         l = e.Size()
 605                         n += 1 + l + sovGenerated(uint64(l))
 606                 }
 607         }
 608         return n
 609 }
 610
 611 func (m *ValidatingWebhookConfigurationList) Size() (n int) {
 612         var l int
 613         _ = l
 614         l = m.ListMeta.Size()
 615         n += 1 + l + sovGenerated(uint64(l))
 616         if len(m.Items) > 0 {
 617                 for _, e := range m.Items {
 618                         l = e.Size()
 619                         n += 1 + l + sovGenerated(uint64(l))
 620                 }
 621         }
 622         return n
 623 }
 624
 625 func (m *Webhook) Size() (n int) {
 626         var l int
 627         _ = l
 628         l = len(m.Name)
 629         n += 1 + l + sovGenerated(uint64(l))
 630         l = m.ClientConfig.Size()
 631         n += 1 + l + sovGenerated(uint64(l))
 632         if len(m.Rules) > 0 {
 633                 for _, e := range m.Rules {
 634                         l = e.Size()
 635                         n += 1 + l + sovGenerated(uint64(l))
 636                 }
 637         }
 638         if m.FailurePolicy != nil {
 639                 l = len(*m.FailurePolicy)
 640                 n += 1 + l + sovGenerated(uint64(l))
 641         }
 642         if m.NamespaceSelector != nil {
 643                 l = m.NamespaceSelector.Size()
 644                 n += 1 + l + sovGenerated(uint64(l))
 645         }
 646         if m.SideEffects != nil {
 647                 l = len(*m.SideEffects)
 648                 n += 1 + l + sovGenerated(uint64(l))
 649         }
 650         return n
 651 }
 652
 653 func (m *WebhookClientConfig) Size() (n int) {
 654         var l int
 655         _ = l
 656         if m.Service != nil {
 657                 l = m.Service.Size()
 658                 n += 1 + l + sovGenerated(uint64(l))
 659         }
 660         if m.CABundle != nil {
 661                 l = len(m.CABundle)
 662                 n += 1 + l + sovGenerated(uint64(l))
 663         }
 664         if m.URL != nil {
 665                 l = len(*m.URL)
 666                 n += 1 + l + sovGenerated(uint64(l))
 667         }
 668         return n
 669 }
 670
 671 func sovGenerated(x uint64) (n int) {
 672         for {
 673                 n++
 674                 x >>= 7
 675                 if x == 0 {
 676                         break
 677                 }
 678         }
 679         return n
 680 }
 681 func sozGenerated(x uint64) (n int) {
 682         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 683 }
 684 func (this *MutatingWebhookConfiguration) String() string {
 685         if this == nil {
 686                 return "nil"
 687         }
 688         s := strings.Join([]string{`&MutatingWebhookConfiguration{`,
 689                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 690                 `Webhooks:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Webhooks), "Webhook", "Webhook", 1), `&`, ``, 1) + `,`,
 691                 `}`,
 692         }, "")
 693         return s
 694 }
 695 func (this *MutatingWebhookConfigurationList) String() string {
 696         if this == nil {
 697                 return "nil"
 698         }
 699         s := strings.Join([]string{`&MutatingWebhookConfigurationList{`,
 700                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 701                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "MutatingWebhookConfiguration", "MutatingWebhookConfiguration", 1), `&`, ``, 1) + `,`,
 702                 `}`,
 703         }, "")
 704         return s
 705 }
 706 func (this *Rule) String() string {
 707         if this == nil {
 708                 return "nil"
 709         }
 710         s := strings.Join([]string{`&Rule{`,
 711                 `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
 712                 `APIVersions:` + fmt.Sprintf("%v", this.APIVersions) + `,`,
 713                 `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
 714                 `}`,
 715         }, "")
 716         return s
 717 }
 718 func (this *RuleWithOperations) String() string {
 719         if this == nil {
 720                 return "nil"
 721         }
 722         s := strings.Join([]string{`&RuleWithOperations{`,
 723                 `Operations:` + fmt.Sprintf("%v", this.Operations) + `,`,
 724                 `Rule:` + strings.Replace(strings.Replace(this.Rule.String(), "Rule", "Rule", 1), `&`, ``, 1) + `,`,
 725                 `}`,
 726         }, "")
 727         return s
 728 }
 729 func (this *ServiceReference) String() string {
 730         if this == nil {
 731                 return "nil"
 732         }
 733         s := strings.Join([]string{`&ServiceReference{`,
 734                 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
 735                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 736                 `Path:` + valueToStringGenerated(this.Path) + `,`,
 737                 `}`,
 738         }, "")
 739         return s
 740 }
 741 func (this *ValidatingWebhookConfiguration) String() string {
 742         if this == nil {
 743                 return "nil"
 744         }
 745         s := strings.Join([]string{`&ValidatingWebhookConfiguration{`,
 746                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 747                 `Webhooks:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Webhooks), "Webhook", "Webhook", 1), `&`, ``, 1) + `,`,
 748                 `}`,
 749         }, "")
 750         return s
 751 }
 752 func (this *ValidatingWebhookConfigurationList) String() string {
 753         if this == nil {
 754                 return "nil"
 755         }
 756         s := strings.Join([]string{`&ValidatingWebhookConfigurationList{`,
 757                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 758                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ValidatingWebhookConfiguration", "ValidatingWebhookConfiguration", 1), `&`, ``, 1) + `,`,
 759                 `}`,
 760         }, "")
 761         return s
 762 }
 763 func (this *Webhook) String() string {
 764         if this == nil {
 765                 return "nil"
 766         }
 767         s := strings.Join([]string{`&Webhook{`,
 768                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 769                 `ClientConfig:` + strings.Replace(strings.Replace(this.ClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1), `&`, ``, 1) + `,`,
 770                 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + `,`,
 771                 `FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
 772                 `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
 773                 `SideEffects:` + valueToStringGenerated(this.SideEffects) + `,`,
 774                 `}`,
 775         }, "")
 776         return s
 777 }
 778 func (this *WebhookClientConfig) String() string {
 779         if this == nil {
 780                 return "nil"
 781         }
 782         s := strings.Join([]string{`&WebhookClientConfig{`,
 783                 `Service:` + strings.Replace(fmt.Sprintf("%v", this.Service), "ServiceReference", "ServiceReference", 1) + `,`,
 784                 `CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
 785                 `URL:` + valueToStringGenerated(this.URL) + `,`,
 786                 `}`,
 787         }, "")
 788         return s
 789 }
 790 func valueToStringGenerated(v interface{}) string {
 791         rv := reflect.ValueOf(v)
 792         if rv.IsNil() {
 793                 return "nil"
 794         }
 795         pv := reflect.Indirect(rv).Interface()
 796         return fmt.Sprintf("*%v", pv)
 797 }
 798 func (m *MutatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
 799         l := len(dAtA)
 800         iNdEx := 0
 801         for iNdEx < l {
 802                 preIndex := iNdEx
 803                 var wire uint64
 804                 for shift := uint(0); ; shift += 7 {
 805                         if shift >= 64 {
 806                                 return ErrIntOverflowGenerated
 807                         }
 808                         if iNdEx >= l {
 809                                 return io.ErrUnexpectedEOF
 810                         }
 811                         b := dAtA[iNdEx]
 812                         iNdEx++
 813                         wire |= (uint64(b) & 0x7F) << shift
 814                         if b < 0x80 {
 815                                 break
 816                         }
 817                 }
 818                 fieldNum := int32(wire >> 3)
 819                 wireType := int(wire & 0x7)
 820                 if wireType == 4 {
 821                         return fmt.Errorf("proto: MutatingWebhookConfiguration: wiretype end group for non-group")
 822                 }
 823                 if fieldNum <= 0 {
 824                         return fmt.Errorf("proto: MutatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
 825                 }
 826                 switch fieldNum {
 827                 case 1:
 828                         if wireType != 2 {
 829                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 830                         }
 831                         var msglen int
 832                         for shift := uint(0); ; shift += 7 {
 833                                 if shift >= 64 {
 834                                         return ErrIntOverflowGenerated
 835                                 }
 836                                 if iNdEx >= l {
 837                                         return io.ErrUnexpectedEOF
 838                                 }
 839                                 b := dAtA[iNdEx]
 840                                 iNdEx++
 841                                 msglen |= (int(b) & 0x7F) << shift
 842                                 if b < 0x80 {
 843                                         break
 844                                 }
 845                         }
 846                         if msglen < 0 {
 847                                 return ErrInvalidLengthGenerated
 848                         }
 849                         postIndex := iNdEx + msglen
 850                         if postIndex > l {
 851                                 return io.ErrUnexpectedEOF
 852                         }
 853                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 854                                 return err
 855                         }
 856                         iNdEx = postIndex
 857                 case 2:
 858                         if wireType != 2 {
 859                                 return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
 860                         }
 861                         var msglen int
 862                         for shift := uint(0); ; shift += 7 {
 863                                 if shift >= 64 {
 864                                         return ErrIntOverflowGenerated
 865                                 }
 866                                 if iNdEx >= l {
 867                                         return io.ErrUnexpectedEOF
 868                                 }
 869                                 b := dAtA[iNdEx]
 870                                 iNdEx++
 871                                 msglen |= (int(b) & 0x7F) << shift
 872                                 if b < 0x80 {
 873                                         break
 874                                 }
 875                         }
 876                         if msglen < 0 {
 877                                 return ErrInvalidLengthGenerated
 878                         }
 879                         postIndex := iNdEx + msglen
 880                         if postIndex > l {
 881                                 return io.ErrUnexpectedEOF
 882                         }
 883                         m.Webhooks = append(m.Webhooks, Webhook{})
 884                         if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 885                                 return err
 886                         }
 887                         iNdEx = postIndex
 888                 default:
 889                         iNdEx = preIndex
 890                         skippy, err := skipGenerated(dAtA[iNdEx:])
 891                         if err != nil {
 892                                 return err
 893                         }
 894                         if skippy < 0 {
 895                                 return ErrInvalidLengthGenerated
 896                         }
 897                         if (iNdEx + skippy) > l {
 898                                 return io.ErrUnexpectedEOF
 899                         }
 900                         iNdEx += skippy
 901                 }
 902         }
 903
 904         if iNdEx > l {
 905                 return io.ErrUnexpectedEOF
 906         }
 907         return nil
 908 }
 909 func (m *MutatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
 910         l := len(dAtA)
 911         iNdEx := 0
 912         for iNdEx < l {
 913                 preIndex := iNdEx
 914                 var wire uint64
 915                 for shift := uint(0); ; shift += 7 {
 916                         if shift >= 64 {
 917                                 return ErrIntOverflowGenerated
 918                         }
 919                         if iNdEx >= l {
 920                                 return io.ErrUnexpectedEOF
 921                         }
 922                         b := dAtA[iNdEx]
 923                         iNdEx++
 924                         wire |= (uint64(b) & 0x7F) << shift
 925                         if b < 0x80 {
 926                                 break
 927                         }
 928                 }
 929                 fieldNum := int32(wire >> 3)
 930                 wireType := int(wire & 0x7)
 931                 if wireType == 4 {
 932                         return fmt.Errorf("proto: MutatingWebhookConfigurationList: wiretype end group for non-group")
 933                 }
 934                 if fieldNum <= 0 {
 935                         return fmt.Errorf("proto: MutatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
 936                 }
 937                 switch fieldNum {
 938                 case 1:
 939                         if wireType != 2 {
 940                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 941                         }
 942                         var msglen int
 943                         for shift := uint(0); ; shift += 7 {
 944                                 if shift >= 64 {
 945                                         return ErrIntOverflowGenerated
 946                                 }
 947                                 if iNdEx >= l {
 948                                         return io.ErrUnexpectedEOF
 949                                 }
 950                                 b := dAtA[iNdEx]
 951                                 iNdEx++
 952                                 msglen |= (int(b) & 0x7F) << shift
 953                                 if b < 0x80 {
 954                                         break
 955                                 }
 956                         }
 957                         if msglen < 0 {
 958                                 return ErrInvalidLengthGenerated
 959                         }
 960                         postIndex := iNdEx + msglen
 961                         if postIndex > l {
 962                                 return io.ErrUnexpectedEOF
 963                         }
 964                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 965                                 return err
 966                         }
 967                         iNdEx = postIndex
 968                 case 2:
 969                         if wireType != 2 {
 970                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 971                         }
 972                         var msglen int
 973                         for shift := uint(0); ; shift += 7 {
 974                                 if shift >= 64 {
 975                                         return ErrIntOverflowGenerated
 976                                 }
 977                                 if iNdEx >= l {
 978                                         return io.ErrUnexpectedEOF
 979                                 }
 980                                 b := dAtA[iNdEx]
 981                                 iNdEx++
 982                                 msglen |= (int(b) & 0x7F) << shift
 983                                 if b < 0x80 {
 984                                         break
 985                                 }
 986                         }
 987                         if msglen < 0 {
 988                                 return ErrInvalidLengthGenerated
 989                         }
 990                         postIndex := iNdEx + msglen
 991                         if postIndex > l {
 992                                 return io.ErrUnexpectedEOF
 993                         }
 994                         m.Items = append(m.Items, MutatingWebhookConfiguration{})
 995                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 996                                 return err
 997                         }
 998                         iNdEx = postIndex
 999                 default:
1000                         iNdEx = preIndex
1001                         skippy, err := skipGenerated(dAtA[iNdEx:])
1002                         if err != nil {
1003                                 return err
1004                         }
1005                         if skippy < 0 {
1006                                 return ErrInvalidLengthGenerated
1007                         }
1008                         if (iNdEx + skippy) > l {
1009                                 return io.ErrUnexpectedEOF
1010                         }
1011                         iNdEx += skippy
1012                 }
1013         }
1014
1015         if iNdEx > l {
1016                 return io.ErrUnexpectedEOF
1017         }
1018         return nil
1019 }
1020 func (m *Rule) Unmarshal(dAtA []byte) error {
1021         l := len(dAtA)
1022         iNdEx := 0
1023         for iNdEx < l {
1024                 preIndex := iNdEx
1025                 var wire uint64
1026                 for shift := uint(0); ; shift += 7 {
1027                         if shift >= 64 {
1028                                 return ErrIntOverflowGenerated
1029                         }
1030                         if iNdEx >= l {
1031                                 return io.ErrUnexpectedEOF
1032                         }
1033                         b := dAtA[iNdEx]
1034                         iNdEx++
1035                         wire |= (uint64(b) & 0x7F) << shift
1036                         if b < 0x80 {
1037                                 break
1038                         }
1039                 }
1040                 fieldNum := int32(wire >> 3)
1041                 wireType := int(wire & 0x7)
1042                 if wireType == 4 {
1043                         return fmt.Errorf("proto: Rule: wiretype end group for non-group")
1044                 }
1045                 if fieldNum <= 0 {
1046                         return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
1047                 }
1048                 switch fieldNum {
1049                 case 1:
1050                         if wireType != 2 {
1051                                 return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
1052                         }
1053                         var stringLen uint64
1054                         for shift := uint(0); ; shift += 7 {
1055                                 if shift >= 64 {
1056                                         return ErrIntOverflowGenerated
1057                                 }
1058                                 if iNdEx >= l {
1059                                         return io.ErrUnexpectedEOF
1060                                 }
1061                                 b := dAtA[iNdEx]
1062                                 iNdEx++
1063                                 stringLen |= (uint64(b) & 0x7F) << shift
1064                                 if b < 0x80 {
1065                                         break
1066                                 }
1067                         }
1068                         intStringLen := int(stringLen)
1069                         if intStringLen < 0 {
1070                                 return ErrInvalidLengthGenerated
1071                         }
1072                         postIndex := iNdEx + intStringLen
1073                         if postIndex > l {
1074                                 return io.ErrUnexpectedEOF
1075                         }
1076                         m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
1077                         iNdEx = postIndex
1078                 case 2:
1079                         if wireType != 2 {
1080                                 return fmt.Errorf("proto: wrong wireType = %d for field APIVersions", wireType)
1081                         }
1082                         var stringLen uint64
1083                         for shift := uint(0); ; shift += 7 {
1084                                 if shift >= 64 {
1085                                         return ErrIntOverflowGenerated
1086                                 }
1087                                 if iNdEx >= l {
1088                                         return io.ErrUnexpectedEOF
1089                                 }
1090                                 b := dAtA[iNdEx]
1091                                 iNdEx++
1092                                 stringLen |= (uint64(b) & 0x7F) << shift
1093                                 if b < 0x80 {
1094                                         break
1095                                 }
1096                         }
1097                         intStringLen := int(stringLen)
1098                         if intStringLen < 0 {
1099                                 return ErrInvalidLengthGenerated
1100                         }
1101                         postIndex := iNdEx + intStringLen
1102                         if postIndex > l {
1103                                 return io.ErrUnexpectedEOF
1104                         }
1105                         m.APIVersions = append(m.APIVersions, string(dAtA[iNdEx:postIndex]))
1106                         iNdEx = postIndex
1107                 case 3:
1108                         if wireType != 2 {
1109                                 return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
1110                         }
1111                         var stringLen uint64
1112                         for shift := uint(0); ; shift += 7 {
1113                                 if shift >= 64 {
1114                                         return ErrIntOverflowGenerated
1115                                 }
1116                                 if iNdEx >= l {
1117                                         return io.ErrUnexpectedEOF
1118                                 }
1119                                 b := dAtA[iNdEx]
1120                                 iNdEx++
1121                                 stringLen |= (uint64(b) & 0x7F) << shift
1122                                 if b < 0x80 {
1123                                         break
1124                                 }
1125                         }
1126                         intStringLen := int(stringLen)
1127                         if intStringLen < 0 {
1128                                 return ErrInvalidLengthGenerated
1129                         }
1130                         postIndex := iNdEx + intStringLen
1131                         if postIndex > l {
1132                                 return io.ErrUnexpectedEOF
1133                         }
1134                         m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
1135                         iNdEx = postIndex
1136                 default:
1137                         iNdEx = preIndex
1138                         skippy, err := skipGenerated(dAtA[iNdEx:])
1139                         if err != nil {
1140                                 return err
1141                         }
1142                         if skippy < 0 {
1143                                 return ErrInvalidLengthGenerated
1144                         }
1145                         if (iNdEx + skippy) > l {
1146                                 return io.ErrUnexpectedEOF
1147                         }
1148                         iNdEx += skippy
1149                 }
1150         }
1151
1152         if iNdEx > l {
1153                 return io.ErrUnexpectedEOF
1154         }
1155         return nil
1156 }
1157 func (m *RuleWithOperations) Unmarshal(dAtA []byte) error {
1158         l := len(dAtA)
1159         iNdEx := 0
1160         for iNdEx < l {
1161                 preIndex := iNdEx
1162                 var wire uint64
1163                 for shift := uint(0); ; shift += 7 {
1164                         if shift >= 64 {
1165                                 return ErrIntOverflowGenerated
1166                         }
1167                         if iNdEx >= l {
1168                                 return io.ErrUnexpectedEOF
1169                         }
1170                         b := dAtA[iNdEx]
1171                         iNdEx++
1172                         wire |= (uint64(b) & 0x7F) << shift
1173                         if b < 0x80 {
1174                                 break
1175                         }
1176                 }
1177                 fieldNum := int32(wire >> 3)
1178                 wireType := int(wire & 0x7)
1179                 if wireType == 4 {
1180                         return fmt.Errorf("proto: RuleWithOperations: wiretype end group for non-group")
1181                 }
1182                 if fieldNum <= 0 {
1183                         return fmt.Errorf("proto: RuleWithOperations: illegal tag %d (wire type %d)", fieldNum, wire)
1184                 }
1185                 switch fieldNum {
1186                 case 1:
1187                         if wireType != 2 {
1188                                 return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType)
1189                         }
1190                         var stringLen uint64
1191                         for shift := uint(0); ; shift += 7 {
1192                                 if shift >= 64 {
1193                                         return ErrIntOverflowGenerated
1194                                 }
1195                                 if iNdEx >= l {
1196                                         return io.ErrUnexpectedEOF
1197                                 }
1198                                 b := dAtA[iNdEx]
1199                                 iNdEx++
1200                                 stringLen |= (uint64(b) & 0x7F) << shift
1201                                 if b < 0x80 {
1202                                         break
1203                                 }
1204                         }
1205                         intStringLen := int(stringLen)
1206                         if intStringLen < 0 {
1207                                 return ErrInvalidLengthGenerated
1208                         }
1209                         postIndex := iNdEx + intStringLen
1210                         if postIndex > l {
1211                                 return io.ErrUnexpectedEOF
1212                         }
1213                         m.Operations = append(m.Operations, OperationType(dAtA[iNdEx:postIndex]))
1214                         iNdEx = postIndex
1215                 case 2:
1216                         if wireType != 2 {
1217                                 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
1218                         }
1219                         var msglen int
1220                         for shift := uint(0); ; shift += 7 {
1221                                 if shift >= 64 {
1222                                         return ErrIntOverflowGenerated
1223                                 }
1224                                 if iNdEx >= l {
1225                                         return io.ErrUnexpectedEOF
1226                                 }
1227                                 b := dAtA[iNdEx]
1228                                 iNdEx++
1229                                 msglen |= (int(b) & 0x7F) << shift
1230                                 if b < 0x80 {
1231                                         break
1232                                 }
1233                         }
1234                         if msglen < 0 {
1235                                 return ErrInvalidLengthGenerated
1236                         }
1237                         postIndex := iNdEx + msglen
1238                         if postIndex > l {
1239                                 return io.ErrUnexpectedEOF
1240                         }
1241                         if err := m.Rule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1242                                 return err
1243                         }
1244                         iNdEx = postIndex
1245                 default:
1246                         iNdEx = preIndex
1247                         skippy, err := skipGenerated(dAtA[iNdEx:])
1248                         if err != nil {
1249                                 return err
1250                         }
1251                         if skippy < 0 {
1252                                 return ErrInvalidLengthGenerated
1253                         }
1254                         if (iNdEx + skippy) > l {
1255                                 return io.ErrUnexpectedEOF
1256                         }
1257                         iNdEx += skippy
1258                 }
1259         }
1260
1261         if iNdEx > l {
1262                 return io.ErrUnexpectedEOF
1263         }
1264         return nil
1265 }
1266 func (m *ServiceReference) Unmarshal(dAtA []byte) error {
1267         l := len(dAtA)
1268         iNdEx := 0
1269         for iNdEx < l {
1270                 preIndex := iNdEx
1271                 var wire uint64
1272                 for shift := uint(0); ; shift += 7 {
1273                         if shift >= 64 {
1274                                 return ErrIntOverflowGenerated
1275                         }
1276                         if iNdEx >= l {
1277                                 return io.ErrUnexpectedEOF
1278                         }
1279                         b := dAtA[iNdEx]
1280                         iNdEx++
1281                         wire |= (uint64(b) & 0x7F) << shift
1282                         if b < 0x80 {
1283                                 break
1284                         }
1285                 }
1286                 fieldNum := int32(wire >> 3)
1287                 wireType := int(wire & 0x7)
1288                 if wireType == 4 {
1289                         return fmt.Errorf("proto: ServiceReference: wiretype end group for non-group")
1290                 }
1291                 if fieldNum <= 0 {
1292                         return fmt.Errorf("proto: ServiceReference: illegal tag %d (wire type %d)", fieldNum, wire)
1293                 }
1294                 switch fieldNum {
1295                 case 1:
1296                         if wireType != 2 {
1297                                 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
1298                         }
1299                         var stringLen uint64
1300                         for shift := uint(0); ; shift += 7 {
1301                                 if shift >= 64 {
1302                                         return ErrIntOverflowGenerated
1303                                 }
1304                                 if iNdEx >= l {
1305                                         return io.ErrUnexpectedEOF
1306                                 }
1307                                 b := dAtA[iNdEx]
1308                                 iNdEx++
1309                                 stringLen |= (uint64(b) & 0x7F) << shift
1310                                 if b < 0x80 {
1311                                         break
1312                                 }
1313                         }
1314                         intStringLen := int(stringLen)
1315                         if intStringLen < 0 {
1316                                 return ErrInvalidLengthGenerated
1317                         }
1318                         postIndex := iNdEx + intStringLen
1319                         if postIndex > l {
1320                                 return io.ErrUnexpectedEOF
1321                         }
1322                         m.Namespace = string(dAtA[iNdEx:postIndex])
1323                         iNdEx = postIndex
1324                 case 2:
1325                         if wireType != 2 {
1326                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1327                         }
1328                         var stringLen uint64
1329                         for shift := uint(0); ; shift += 7 {
1330                                 if shift >= 64 {
1331                                         return ErrIntOverflowGenerated
1332                                 }
1333                                 if iNdEx >= l {
1334                                         return io.ErrUnexpectedEOF
1335                                 }
1336                                 b := dAtA[iNdEx]
1337                                 iNdEx++
1338                                 stringLen |= (uint64(b) & 0x7F) << shift
1339                                 if b < 0x80 {
1340                                         break
1341                                 }
1342                         }
1343                         intStringLen := int(stringLen)
1344                         if intStringLen < 0 {
1345                                 return ErrInvalidLengthGenerated
1346                         }
1347                         postIndex := iNdEx + intStringLen
1348                         if postIndex > l {
1349                                 return io.ErrUnexpectedEOF
1350                         }
1351                         m.Name = string(dAtA[iNdEx:postIndex])
1352                         iNdEx = postIndex
1353                 case 3:
1354                         if wireType != 2 {
1355                                 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
1356                         }
1357                         var stringLen uint64
1358                         for shift := uint(0); ; shift += 7 {
1359                                 if shift >= 64 {
1360                                         return ErrIntOverflowGenerated
1361                                 }
1362                                 if iNdEx >= l {
1363                                         return io.ErrUnexpectedEOF
1364                                 }
1365                                 b := dAtA[iNdEx]
1366                                 iNdEx++
1367                                 stringLen |= (uint64(b) & 0x7F) << shift
1368                                 if b < 0x80 {
1369                                         break
1370                                 }
1371                         }
1372                         intStringLen := int(stringLen)
1373                         if intStringLen < 0 {
1374                                 return ErrInvalidLengthGenerated
1375                         }
1376                         postIndex := iNdEx + intStringLen
1377                         if postIndex > l {
1378                                 return io.ErrUnexpectedEOF
1379                         }
1380                         s := string(dAtA[iNdEx:postIndex])
1381                         m.Path = &s
1382                         iNdEx = postIndex
1383                 default:
1384                         iNdEx = preIndex
1385                         skippy, err := skipGenerated(dAtA[iNdEx:])
1386                         if err != nil {
1387                                 return err
1388                         }
1389                         if skippy < 0 {
1390                                 return ErrInvalidLengthGenerated
1391                         }
1392                         if (iNdEx + skippy) > l {
1393                                 return io.ErrUnexpectedEOF
1394                         }
1395                         iNdEx += skippy
1396                 }
1397         }
1398
1399         if iNdEx > l {
1400                 return io.ErrUnexpectedEOF
1401         }
1402         return nil
1403 }
1404 func (m *ValidatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
1405         l := len(dAtA)
1406         iNdEx := 0
1407         for iNdEx < l {
1408                 preIndex := iNdEx
1409                 var wire uint64
1410                 for shift := uint(0); ; shift += 7 {
1411                         if shift >= 64 {
1412                                 return ErrIntOverflowGenerated
1413                         }
1414                         if iNdEx >= l {
1415                                 return io.ErrUnexpectedEOF
1416                         }
1417                         b := dAtA[iNdEx]
1418                         iNdEx++
1419                         wire |= (uint64(b) & 0x7F) << shift
1420                         if b < 0x80 {
1421                                 break
1422                         }
1423                 }
1424                 fieldNum := int32(wire >> 3)
1425                 wireType := int(wire & 0x7)
1426                 if wireType == 4 {
1427                         return fmt.Errorf("proto: ValidatingWebhookConfiguration: wiretype end group for non-group")
1428                 }
1429                 if fieldNum <= 0 {
1430                         return fmt.Errorf("proto: ValidatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
1431                 }
1432                 switch fieldNum {
1433                 case 1:
1434                         if wireType != 2 {
1435                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1436                         }
1437                         var msglen int
1438                         for shift := uint(0); ; shift += 7 {
1439                                 if shift >= 64 {
1440                                         return ErrIntOverflowGenerated
1441                                 }
1442                                 if iNdEx >= l {
1443                                         return io.ErrUnexpectedEOF
1444                                 }
1445                                 b := dAtA[iNdEx]
1446                                 iNdEx++
1447                                 msglen |= (int(b) & 0x7F) << shift
1448                                 if b < 0x80 {
1449                                         break
1450                                 }
1451                         }
1452                         if msglen < 0 {
1453                                 return ErrInvalidLengthGenerated
1454                         }
1455                         postIndex := iNdEx + msglen
1456                         if postIndex > l {
1457                                 return io.ErrUnexpectedEOF
1458                         }
1459                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1460                                 return err
1461                         }
1462                         iNdEx = postIndex
1463                 case 2:
1464                         if wireType != 2 {
1465                                 return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
1466                         }
1467                         var msglen int
1468                         for shift := uint(0); ; shift += 7 {
1469                                 if shift >= 64 {
1470                                         return ErrIntOverflowGenerated
1471                                 }
1472                                 if iNdEx >= l {
1473                                         return io.ErrUnexpectedEOF
1474                                 }
1475                                 b := dAtA[iNdEx]
1476                                 iNdEx++
1477                                 msglen |= (int(b) & 0x7F) << shift
1478                                 if b < 0x80 {
1479                                         break
1480                                 }
1481                         }
1482                         if msglen < 0 {
1483                                 return ErrInvalidLengthGenerated
1484                         }
1485                         postIndex := iNdEx + msglen
1486                         if postIndex > l {
1487                                 return io.ErrUnexpectedEOF
1488                         }
1489                         m.Webhooks = append(m.Webhooks, Webhook{})
1490                         if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1491                                 return err
1492                         }
1493                         iNdEx = postIndex
1494                 default:
1495                         iNdEx = preIndex
1496                         skippy, err := skipGenerated(dAtA[iNdEx:])
1497                         if err != nil {
1498                                 return err
1499                         }
1500                         if skippy < 0 {
1501                                 return ErrInvalidLengthGenerated
1502                         }
1503                         if (iNdEx + skippy) > l {
1504                                 return io.ErrUnexpectedEOF
1505                         }
1506                         iNdEx += skippy
1507                 }
1508         }
1509
1510         if iNdEx > l {
1511                 return io.ErrUnexpectedEOF
1512         }
1513         return nil
1514 }
1515 func (m *ValidatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
1516         l := len(dAtA)
1517         iNdEx := 0
1518         for iNdEx < l {
1519                 preIndex := iNdEx
1520                 var wire uint64
1521                 for shift := uint(0); ; shift += 7 {
1522                         if shift >= 64 {
1523                                 return ErrIntOverflowGenerated
1524                         }
1525                         if iNdEx >= l {
1526                                 return io.ErrUnexpectedEOF
1527                         }
1528                         b := dAtA[iNdEx]
1529                         iNdEx++
1530                         wire |= (uint64(b) & 0x7F) << shift
1531                         if b < 0x80 {
1532                                 break
1533                         }
1534                 }
1535                 fieldNum := int32(wire >> 3)
1536                 wireType := int(wire & 0x7)
1537                 if wireType == 4 {
1538                         return fmt.Errorf("proto: ValidatingWebhookConfigurationList: wiretype end group for non-group")
1539                 }
1540                 if fieldNum <= 0 {
1541                         return fmt.Errorf("proto: ValidatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
1542                 }
1543                 switch fieldNum {
1544                 case 1:
1545                         if wireType != 2 {
1546                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1547                         }
1548                         var msglen int
1549                         for shift := uint(0); ; shift += 7 {
1550                                 if shift >= 64 {
1551                                         return ErrIntOverflowGenerated
1552                                 }
1553                                 if iNdEx >= l {
1554                                         return io.ErrUnexpectedEOF
1555                                 }
1556                                 b := dAtA[iNdEx]
1557                                 iNdEx++
1558                                 msglen |= (int(b) & 0x7F) << shift
1559                                 if b < 0x80 {
1560                                         break
1561                                 }
1562                         }
1563                         if msglen < 0 {
1564                                 return ErrInvalidLengthGenerated
1565                         }
1566                         postIndex := iNdEx + msglen
1567                         if postIndex > l {
1568                                 return io.ErrUnexpectedEOF
1569                         }
1570                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1571                                 return err
1572                         }
1573                         iNdEx = postIndex
1574                 case 2:
1575                         if wireType != 2 {
1576                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1577                         }
1578                         var msglen int
1579                         for shift := uint(0); ; shift += 7 {
1580                                 if shift >= 64 {
1581                                         return ErrIntOverflowGenerated
1582                                 }
1583                                 if iNdEx >= l {
1584                                         return io.ErrUnexpectedEOF
1585                                 }
1586                                 b := dAtA[iNdEx]
1587                                 iNdEx++
1588                                 msglen |= (int(b) & 0x7F) << shift
1589                                 if b < 0x80 {
1590                                         break
1591                                 }
1592                         }
1593                         if msglen < 0 {
1594                                 return ErrInvalidLengthGenerated
1595                         }
1596                         postIndex := iNdEx + msglen
1597                         if postIndex > l {
1598                                 return io.ErrUnexpectedEOF
1599                         }
1600                         m.Items = append(m.Items, ValidatingWebhookConfiguration{})
1601                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1602                                 return err
1603                         }
1604                         iNdEx = postIndex
1605                 default:
1606                         iNdEx = preIndex
1607                         skippy, err := skipGenerated(dAtA[iNdEx:])
1608                         if err != nil {
1609                                 return err
1610                         }
1611                         if skippy < 0 {
1612                                 return ErrInvalidLengthGenerated
1613                         }
1614                         if (iNdEx + skippy) > l {
1615                                 return io.ErrUnexpectedEOF
1616                         }
1617                         iNdEx += skippy
1618                 }
1619         }
1620
1621         if iNdEx > l {
1622                 return io.ErrUnexpectedEOF
1623         }
1624         return nil
1625 }
1626 func (m *Webhook) Unmarshal(dAtA []byte) error {
1627         l := len(dAtA)
1628         iNdEx := 0
1629         for iNdEx < l {
1630                 preIndex := iNdEx
1631                 var wire uint64
1632                 for shift := uint(0); ; shift += 7 {
1633                         if shift >= 64 {
1634                                 return ErrIntOverflowGenerated
1635                         }
1636                         if iNdEx >= l {
1637                                 return io.ErrUnexpectedEOF
1638                         }
1639                         b := dAtA[iNdEx]
1640                         iNdEx++
1641                         wire |= (uint64(b) & 0x7F) << shift
1642                         if b < 0x80 {
1643                                 break
1644                         }
1645                 }
1646                 fieldNum := int32(wire >> 3)
1647                 wireType := int(wire & 0x7)
1648                 if wireType == 4 {
1649                         return fmt.Errorf("proto: Webhook: wiretype end group for non-group")
1650                 }
1651                 if fieldNum <= 0 {
1652                         return fmt.Errorf("proto: Webhook: illegal tag %d (wire type %d)", fieldNum, wire)
1653                 }
1654                 switch fieldNum {
1655                 case 1:
1656                         if wireType != 2 {
1657                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1658                         }
1659                         var stringLen uint64
1660                         for shift := uint(0); ; shift += 7 {
1661                                 if shift >= 64 {
1662                                         return ErrIntOverflowGenerated
1663                                 }
1664                                 if iNdEx >= l {
1665                                         return io.ErrUnexpectedEOF
1666                                 }
1667                                 b := dAtA[iNdEx]
1668                                 iNdEx++
1669                                 stringLen |= (uint64(b) & 0x7F) << shift
1670                                 if b < 0x80 {
1671                                         break
1672                                 }
1673                         }
1674                         intStringLen := int(stringLen)
1675                         if intStringLen < 0 {
1676                                 return ErrInvalidLengthGenerated
1677                         }
1678                         postIndex := iNdEx + intStringLen
1679                         if postIndex > l {
1680                                 return io.ErrUnexpectedEOF
1681                         }
1682                         m.Name = string(dAtA[iNdEx:postIndex])
1683                         iNdEx = postIndex
1684                 case 2:
1685                         if wireType != 2 {
1686                                 return fmt.Errorf("proto: wrong wireType = %d for field ClientConfig", wireType)
1687                         }
1688                         var msglen int
1689                         for shift := uint(0); ; shift += 7 {
1690                                 if shift >= 64 {
1691                                         return ErrIntOverflowGenerated
1692                                 }
1693                                 if iNdEx >= l {
1694                                         return io.ErrUnexpectedEOF
1695                                 }
1696                                 b := dAtA[iNdEx]
1697                                 iNdEx++
1698                                 msglen |= (int(b) & 0x7F) << shift
1699                                 if b < 0x80 {
1700                                         break
1701                                 }
1702                         }
1703                         if msglen < 0 {
1704                                 return ErrInvalidLengthGenerated
1705                         }
1706                         postIndex := iNdEx + msglen
1707                         if postIndex > l {
1708                                 return io.ErrUnexpectedEOF
1709                         }
1710                         if err := m.ClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1711                                 return err
1712                         }
1713                         iNdEx = postIndex
1714                 case 3:
1715                         if wireType != 2 {
1716                                 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
1717                         }
1718                         var msglen int
1719                         for shift := uint(0); ; shift += 7 {
1720                                 if shift >= 64 {
1721                                         return ErrIntOverflowGenerated
1722                                 }
1723                                 if iNdEx >= l {
1724                                         return io.ErrUnexpectedEOF
1725                                 }
1726                                 b := dAtA[iNdEx]
1727                                 iNdEx++
1728                                 msglen |= (int(b) & 0x7F) << shift
1729                                 if b < 0x80 {
1730                                         break
1731                                 }
1732                         }
1733                         if msglen < 0 {
1734                                 return ErrInvalidLengthGenerated
1735                         }
1736                         postIndex := iNdEx + msglen
1737                         if postIndex > l {
1738                                 return io.ErrUnexpectedEOF
1739                         }
1740                         m.Rules = append(m.Rules, RuleWithOperations{})
1741                         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1742                                 return err
1743                         }
1744                         iNdEx = postIndex
1745                 case 4:
1746                         if wireType != 2 {
1747                                 return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
1748                         }
1749                         var stringLen uint64
1750                         for shift := uint(0); ; shift += 7 {
1751                                 if shift >= 64 {
1752                                         return ErrIntOverflowGenerated
1753                                 }
1754                                 if iNdEx >= l {
1755                                         return io.ErrUnexpectedEOF
1756                                 }
1757                                 b := dAtA[iNdEx]
1758                                 iNdEx++
1759                                 stringLen |= (uint64(b) & 0x7F) << shift
1760                                 if b < 0x80 {
1761                                         break
1762                                 }
1763                         }
1764                         intStringLen := int(stringLen)
1765                         if intStringLen < 0 {
1766                                 return ErrInvalidLengthGenerated
1767                         }
1768                         postIndex := iNdEx + intStringLen
1769                         if postIndex > l {
1770                                 return io.ErrUnexpectedEOF
1771                         }
1772                         s := FailurePolicyType(dAtA[iNdEx:postIndex])
1773                         m.FailurePolicy = &s
1774                         iNdEx = postIndex
1775                 case 5:
1776                         if wireType != 2 {
1777                                 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
1778                         }
1779                         var msglen int
1780                         for shift := uint(0); ; shift += 7 {
1781                                 if shift >= 64 {
1782                                         return ErrIntOverflowGenerated
1783                                 }
1784                                 if iNdEx >= l {
1785                                         return io.ErrUnexpectedEOF
1786                                 }
1787                                 b := dAtA[iNdEx]
1788                                 iNdEx++
1789                                 msglen |= (int(b) & 0x7F) << shift
1790                                 if b < 0x80 {
1791                                         break
1792                                 }
1793                         }
1794                         if msglen < 0 {
1795                                 return ErrInvalidLengthGenerated
1796                         }
1797                         postIndex := iNdEx + msglen
1798                         if postIndex > l {
1799                                 return io.ErrUnexpectedEOF
1800                         }
1801                         if m.NamespaceSelector == nil {
1802                                 m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
1803                         }
1804                         if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1805                                 return err
1806                         }
1807                         iNdEx = postIndex
1808                 case 6:
1809                         if wireType != 2 {
1810                                 return fmt.Errorf("proto: wrong wireType = %d for field SideEffects", wireType)
1811                         }
1812                         var stringLen uint64
1813                         for shift := uint(0); ; shift += 7 {
1814                                 if shift >= 64 {
1815                                         return ErrIntOverflowGenerated
1816                                 }
1817                                 if iNdEx >= l {
1818                                         return io.ErrUnexpectedEOF
1819                                 }
1820                                 b := dAtA[iNdEx]
1821                                 iNdEx++
1822                                 stringLen |= (uint64(b) & 0x7F) << shift
1823                                 if b < 0x80 {
1824                                         break
1825                                 }
1826                         }
1827                         intStringLen := int(stringLen)
1828                         if intStringLen < 0 {
1829                                 return ErrInvalidLengthGenerated
1830                         }
1831                         postIndex := iNdEx + intStringLen
1832                         if postIndex > l {
1833                                 return io.ErrUnexpectedEOF
1834                         }
1835                         s := SideEffectClass(dAtA[iNdEx:postIndex])
1836                         m.SideEffects = &s
1837                         iNdEx = postIndex
1838                 default:
1839                         iNdEx = preIndex
1840                         skippy, err := skipGenerated(dAtA[iNdEx:])
1841                         if err != nil {
1842                                 return err
1843                         }
1844                         if skippy < 0 {
1845                                 return ErrInvalidLengthGenerated
1846                         }
1847                         if (iNdEx + skippy) > l {
1848                                 return io.ErrUnexpectedEOF
1849                         }
1850                         iNdEx += skippy
1851                 }
1852         }
1853
1854         if iNdEx > l {
1855                 return io.ErrUnexpectedEOF
1856         }
1857         return nil
1858 }
1859 func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error {
1860         l := len(dAtA)
1861         iNdEx := 0
1862         for iNdEx < l {
1863                 preIndex := iNdEx
1864                 var wire uint64
1865                 for shift := uint(0); ; shift += 7 {
1866                         if shift >= 64 {
1867                                 return ErrIntOverflowGenerated
1868                         }
1869                         if iNdEx >= l {
1870                                 return io.ErrUnexpectedEOF
1871                         }
1872                         b := dAtA[iNdEx]
1873                         iNdEx++
1874                         wire |= (uint64(b) & 0x7F) << shift
1875                         if b < 0x80 {
1876                                 break
1877                         }
1878                 }
1879                 fieldNum := int32(wire >> 3)
1880                 wireType := int(wire & 0x7)
1881                 if wireType == 4 {
1882                         return fmt.Errorf("proto: WebhookClientConfig: wiretype end group for non-group")
1883                 }
1884                 if fieldNum <= 0 {
1885                         return fmt.Errorf("proto: WebhookClientConfig: illegal tag %d (wire type %d)", fieldNum, wire)
1886                 }
1887                 switch fieldNum {
1888                 case 1:
1889                         if wireType != 2 {
1890                                 return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
1891                         }
1892                         var msglen int
1893                         for shift := uint(0); ; shift += 7 {
1894                                 if shift >= 64 {
1895                                         return ErrIntOverflowGenerated
1896                                 }
1897                                 if iNdEx >= l {
1898                                         return io.ErrUnexpectedEOF
1899                                 }
1900                                 b := dAtA[iNdEx]
1901                                 iNdEx++
1902                                 msglen |= (int(b) & 0x7F) << shift
1903                                 if b < 0x80 {
1904                                         break
1905                                 }
1906                         }
1907                         if msglen < 0 {
1908                                 return ErrInvalidLengthGenerated
1909                         }
1910                         postIndex := iNdEx + msglen
1911                         if postIndex > l {
1912                                 return io.ErrUnexpectedEOF
1913                         }
1914                         if m.Service == nil {
1915                                 m.Service = &ServiceReference{}
1916                         }
1917                         if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1918                                 return err
1919                         }
1920                         iNdEx = postIndex
1921                 case 2:
1922                         if wireType != 2 {
1923                                 return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
1924                         }
1925                         var byteLen int
1926                         for shift := uint(0); ; shift += 7 {
1927                                 if shift >= 64 {
1928                                         return ErrIntOverflowGenerated
1929                                 }
1930                                 if iNdEx >= l {
1931                                         return io.ErrUnexpectedEOF
1932                                 }
1933                                 b := dAtA[iNdEx]
1934                                 iNdEx++
1935                                 byteLen |= (int(b) & 0x7F) << shift
1936                                 if b < 0x80 {
1937                                         break
1938                                 }
1939                         }
1940                         if byteLen < 0 {
1941                                 return ErrInvalidLengthGenerated
1942                         }
1943                         postIndex := iNdEx + byteLen
1944                         if postIndex > l {
1945                                 return io.ErrUnexpectedEOF
1946                         }
1947                         m.CABundle = append(m.CABundle[:0], dAtA[iNdEx:postIndex]...)
1948                         if m.CABundle == nil {
1949                                 m.CABundle = []byte{}
1950                         }
1951                         iNdEx = postIndex
1952                 case 3:
1953                         if wireType != 2 {
1954                                 return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
1955                         }
1956                         var stringLen uint64
1957                         for shift := uint(0); ; shift += 7 {
1958                                 if shift >= 64 {
1959                                         return ErrIntOverflowGenerated
1960                                 }
1961                                 if iNdEx >= l {
1962                                         return io.ErrUnexpectedEOF
1963                                 }
1964                                 b := dAtA[iNdEx]
1965                                 iNdEx++
1966                                 stringLen |= (uint64(b) & 0x7F) << shift
1967                                 if b < 0x80 {
1968                                         break
1969                                 }
1970                         }
1971                         intStringLen := int(stringLen)
1972                         if intStringLen < 0 {
1973                                 return ErrInvalidLengthGenerated
1974                         }
1975                         postIndex := iNdEx + intStringLen
1976                         if postIndex > l {
1977                                 return io.ErrUnexpectedEOF
1978                         }
1979                         s := string(dAtA[iNdEx:postIndex])
1980                         m.URL = &s
1981                         iNdEx = postIndex
1982                 default:
1983                         iNdEx = preIndex
1984                         skippy, err := skipGenerated(dAtA[iNdEx:])
1985                         if err != nil {
1986                                 return err
1987                         }
1988                         if skippy < 0 {
1989                                 return ErrInvalidLengthGenerated
1990                         }
1991                         if (iNdEx + skippy) > l {
1992                                 return io.ErrUnexpectedEOF
1993                         }
1994                         iNdEx += skippy
1995                 }
1996         }
1997
1998         if iNdEx > l {
1999                 return io.ErrUnexpectedEOF
2000         }
2001         return nil
2002 }
2003 func skipGenerated(dAtA []byte) (n int, err error) {
2004         l := len(dAtA)
2005         iNdEx := 0
2006         for iNdEx < l {
2007                 var wire uint64
2008                 for shift := uint(0); ; shift += 7 {
2009                         if shift >= 64 {
2010                                 return 0, ErrIntOverflowGenerated
2011                         }
2012                         if iNdEx >= l {
2013                                 return 0, io.ErrUnexpectedEOF
2014                         }
2015                         b := dAtA[iNdEx]
2016                         iNdEx++
2017                         wire |= (uint64(b) & 0x7F) << shift
2018                         if b < 0x80 {
2019                                 break
2020                         }
2021                 }
2022                 wireType := int(wire & 0x7)
2023                 switch wireType {
2024                 case 0:
2025                         for shift := uint(0); ; shift += 7 {
2026                                 if shift >= 64 {
2027                                         return 0, ErrIntOverflowGenerated
2028                                 }
2029                                 if iNdEx >= l {
2030                                         return 0, io.ErrUnexpectedEOF
2031                                 }
2032                                 iNdEx++
2033                                 if dAtA[iNdEx-1] < 0x80 {
2034                                         break
2035                                 }
2036                         }
2037                         return iNdEx, nil
2038                 case 1:
2039                         iNdEx += 8
2040                         return iNdEx, nil
2041                 case 2:
2042                         var length int
2043                         for shift := uint(0); ; shift += 7 {
2044                                 if shift >= 64 {
2045                                         return 0, ErrIntOverflowGenerated
2046                                 }
2047                                 if iNdEx >= l {
2048                                         return 0, io.ErrUnexpectedEOF
2049                                 }
2050                                 b := dAtA[iNdEx]
2051                                 iNdEx++
2052                                 length |= (int(b) & 0x7F) << shift
2053                                 if b < 0x80 {
2054                                         break
2055                                 }
2056                         }
2057                         iNdEx += length
2058                         if length < 0 {
2059                                 return 0, ErrInvalidLengthGenerated
2060                         }
2061                         return iNdEx, nil
2062                 case 3:
2063                         for {
2064                                 var innerWire uint64
2065                                 var start int = iNdEx
2066                                 for shift := uint(0); ; shift += 7 {
2067                                         if shift >= 64 {
2068                                                 return 0, ErrIntOverflowGenerated
2069                                         }
2070                                         if iNdEx >= l {
2071                                                 return 0, io.ErrUnexpectedEOF
2072                                         }
2073                                         b := dAtA[iNdEx]
2074                                         iNdEx++
2075                                         innerWire |= (uint64(b) & 0x7F) << shift
2076                                         if b < 0x80 {
2077                                                 break
2078                                         }
2079                                 }
2080                                 innerWireType := int(innerWire & 0x7)
2081                                 if innerWireType == 4 {
2082                                         break
2083                                 }
2084                                 next, err := skipGenerated(dAtA[start:])
2085                                 if err != nil {
2086                                         return 0, err
2087                                 }
2088                                 iNdEx = start + next
2089                         }
2090                         return iNdEx, nil
2091                 case 4:
2092                         return iNdEx, nil
2093                 case 5:
2094                         iNdEx += 4
2095                         return iNdEx, nil
2096                 default:
2097                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2098                 }
2099         }
2100         panic("unreachable")
2101 }
2102
2103 var (
2104         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
2105         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
2106 )
2107
2108 func init() {
2109         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto", fileDescriptorGenerated)
2110 }
2111
2112 var fileDescriptorGenerated = []byte{
2113         // 906 bytes of a gzipped FileDescriptorProto
2114         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x54, 0xcf, 0x6f, 0xe3, 0x44,
2115         0x14, 0x8e, 0x37, 0x29, 0x49, 0x26, 0x89, 0x76, 0x3b, 0x80, 0x14, 0xaa, 0x95, 0x1d, 0xe5, 0x80,
2116         0x22, 0xa1, 0xb5, 0x49, 0x41, 0x08, 0x21, 0x10, 0xaa, 0x0b, 0x0b, 0x95, 0xba, 0xbb, 0x61, 0x0a,
2117         0xbb, 0x12, 0xe2, 0xc0, 0xc4, 0x79, 0x49, 0x86, 0xf8, 0x97, 0x66, 0xc6, 0x59, 0x7a, 0x43, 0xe2,
2118         0x1f, 0x40, 0x42, 0xfc, 0x0d, 0xfc, 0x15, 0xdc, 0x7b, 0xdc, 0x0b, 0x62, 0x4f, 0x16, 0x35, 0x67,
2119         0x0e, 0x5c, 0x7b, 0x42, 0x63, 0x3b, 0x71, 0xd2, 0x6c, 0xbb, 0xe9, 0x85, 0x03, 0x37, 0xcf, 0xf7,
2120         0xe6, 0xfb, 0xde, 0xfb, 0x9e, 0xdf, 0x1b, 0xf4, 0xc5, 0xec, 0x7d, 0x61, 0xb2, 0xc0, 0x9a, 0x45,
2121         0x43, 0xe0, 0x3e, 0x48, 0x10, 0xd6, 0x1c, 0xfc, 0x51, 0xc0, 0xad, 0x3c, 0x40, 0x43, 0x66, 0xd1,
2122         0x91, 0xc7, 0x84, 0x60, 0x81, 0xcf, 0x61, 0xc2, 0x84, 0xe4, 0x54, 0xb2, 0xc0, 0xb7, 0xe6, 0xfd,
2123         0x21, 0x48, 0xda, 0xb7, 0x26, 0xe0, 0x03, 0xa7, 0x12, 0x46, 0x66, 0xc8, 0x03, 0x19, 0xe0, 0x5e,
2124         0xc6, 0x34, 0x69, 0xc8, 0xcc, 0x17, 0x32, 0xcd, 0x9c, 0xb9, 0x77, 0x6f, 0xc2, 0xe4, 0x34, 0x1a,
2125         0x9a, 0x4e, 0xe0, 0x59, 0x93, 0x60, 0x12, 0x58, 0xa9, 0xc0, 0x30, 0x1a, 0xa7, 0xa7, 0xf4, 0x90,
2126         0x7e, 0x65, 0xc2, 0x7b, 0xef, 0x16, 0x25, 0x79, 0xd4, 0x99, 0x32, 0x1f, 0xf8, 0xa9, 0x15, 0xce,
2127         0x26, 0x0a, 0x10, 0x96, 0x07, 0x92, 0x5a, 0xf3, 0x8d, 0x72, 0xf6, 0xac, 0xab, 0x58, 0x3c, 0xf2,
2128         0x25, 0xf3, 0x60, 0x83, 0xf0, 0xde, 0xcb, 0x08, 0xc2, 0x99, 0x82, 0x47, 0x2f, 0xf3, 0xba, 0xbf,
2129         0x6b, 0xe8, 0xee, 0x83, 0x48, 0x52, 0xc9, 0xfc, 0xc9, 0x13, 0x18, 0x4e, 0x83, 0x60, 0x76, 0x18,
2130         0xf8, 0x63, 0x36, 0x89, 0x32, 0xdb, 0xf8, 0x5b, 0x54, 0x53, 0x45, 0x8e, 0xa8, 0xa4, 0x6d, 0xad,
2131         0xa3, 0xf5, 0x1a, 0xfb, 0x6f, 0x9b, 0x45, 0xaf, 0x96, 0xb9, 0xcc, 0x70, 0x36, 0x51, 0x80, 0x30,
2132         0xd5, 0x6d, 0x73, 0xde, 0x37, 0x1f, 0x0d, 0xbf, 0x03, 0x47, 0x3e, 0x00, 0x49, 0x6d, 0x7c, 0x16,
2133         0x1b, 0xa5, 0x24, 0x36, 0x50, 0x81, 0x91, 0xa5, 0x2a, 0x3e, 0x41, 0xb5, 0x3c, 0xb3, 0x68, 0xdf,
2134         0xea, 0x94, 0x7b, 0x8d, 0xfd, 0xbe, 0xb9, 0xed, 0xdf, 0x30, 0x73, 0xa6, 0x5d, 0x51, 0x29, 0x48,
2135         0xed, 0x69, 0x2e, 0xd4, 0xfd, 0x5b, 0x43, 0x9d, 0xeb, 0x7c, 0x1d, 0x33, 0x21, 0xf1, 0x37, 0x1b,
2136         0xde, 0xcc, 0xed, 0xbc, 0x29, 0x76, 0xea, 0xec, 0x4e, 0xee, 0xac, 0xb6, 0x40, 0x56, 0x7c, 0xcd,
2137         0xd0, 0x0e, 0x93, 0xe0, 0x2d, 0x4c, 0xdd, 0xdf, 0xde, 0xd4, 0x75, 0x85, 0xdb, 0xad, 0x3c, 0xe5,
2138         0xce, 0x91, 0x12, 0x27, 0x59, 0x8e, 0xee, 0xcf, 0x1a, 0xaa, 0x90, 0xc8, 0x05, 0xfc, 0x16, 0xaa,
2139         0xd3, 0x90, 0x7d, 0xc6, 0x83, 0x28, 0x14, 0x6d, 0xad, 0x53, 0xee, 0xd5, 0xed, 0x56, 0x12, 0x1b,
2140         0xf5, 0x83, 0xc1, 0x51, 0x06, 0x92, 0x22, 0x8e, 0xfb, 0xa8, 0x41, 0x43, 0xf6, 0x18, 0xb8, 0x2a,
2141         0x25, 0x2b, 0xb4, 0x6e, 0xdf, 0x4e, 0x62, 0xa3, 0x71, 0x30, 0x38, 0x5a, 0xc0, 0x64, 0xf5, 0x8e,
2142         0xd2, 0xe7, 0x20, 0x82, 0x88, 0x3b, 0x20, 0xda, 0xe5, 0x42, 0x9f, 0x2c, 0x40, 0x52, 0xc4, 0xbb,
2143         0xbf, 0x6a, 0x08, 0xab, 0xaa, 0x9e, 0x30, 0x39, 0x7d, 0x14, 0x42, 0xe6, 0x40, 0xe0, 0x8f, 0x11,
2144         0x0a, 0x96, 0xa7, 0xbc, 0x48, 0x23, 0x9d, 0x8f, 0x25, 0x7a, 0x11, 0x1b, 0xad, 0xe5, 0xe9, 0xcb,
2145         0xd3, 0x10, 0xc8, 0x0a, 0x05, 0x0f, 0x50, 0x85, 0x47, 0x2e, 0xb4, 0x6f, 0x6d, 0xfc, 0xb4, 0x97,
2146         0x74, 0x56, 0x15, 0x63, 0x37, 0xf3, 0x0e, 0xa6, 0x0d, 0x23, 0xa9, 0x52, 0xf7, 0x47, 0x0d, 0xdd,
2147         0x39, 0x01, 0x3e, 0x67, 0x0e, 0x10, 0x18, 0x03, 0x07, 0xdf, 0x01, 0x6c, 0xa1, 0xba, 0x4f, 0x3d,
2148         0x10, 0x21, 0x75, 0x20, 0x1d, 0x90, 0xba, 0xbd, 0x9b, 0x73, 0xeb, 0x0f, 0x17, 0x01, 0x52, 0xdc,
2149         0xc1, 0x1d, 0x54, 0x51, 0x87, 0xb4, 0xae, 0x7a, 0x91, 0x47, 0xdd, 0x25, 0x69, 0x04, 0xdf, 0x45,
2150         0x95, 0x90, 0xca, 0x69, 0xbb, 0x9c, 0xde, 0xa8, 0xa9, 0xe8, 0x80, 0xca, 0x29, 0x49, 0xd1, 0xee,
2151         0x1f, 0x1a, 0xd2, 0x1f, 0x53, 0x97, 0x8d, 0xfe, 0x77, 0xfb, 0xf8, 0x8f, 0x86, 0xba, 0xd7, 0x3b,
2152         0xfb, 0x0f, 0x36, 0xd2, 0x5b, 0xdf, 0xc8, 0xcf, 0xb7, 0xb7, 0x75, 0x7d, 0xe9, 0x57, 0xec, 0xe4,
2153         0x2f, 0x15, 0x54, 0xcd, 0xaf, 0x2f, 0x27, 0x43, 0xbb, 0x72, 0x32, 0x9e, 0xa2, 0xa6, 0xe3, 0x32,
2154         0xf0, 0x65, 0x26, 0x9d, 0xcf, 0xf6, 0x47, 0x37, 0x6e, 0xfd, 0xe1, 0x8a, 0x88, 0xfd, 0x5a, 0x9e,
2155         0xa8, 0xb9, 0x8a, 0x92, 0xb5, 0x44, 0x98, 0xa2, 0x1d, 0xb5, 0x02, 0xd9, 0x36, 0x37, 0xf6, 0x3f,
2156         0xbc, 0xd9, 0x36, 0xad, 0xaf, 0x76, 0xd1, 0x09, 0x15, 0x13, 0x24, 0x53, 0xc6, 0xc7, 0xa8, 0x35,
2157         0xa6, 0xcc, 0x8d, 0x38, 0x0c, 0x02, 0x97, 0x39, 0xa7, 0xed, 0x4a, 0xda, 0x86, 0x37, 0x93, 0xd8,
2158         0x68, 0xdd, 0x5f, 0x0d, 0x5c, 0xc4, 0xc6, 0xee, 0x1a, 0x90, 0xae, 0xfe, 0x3a, 0x19, 0x7f, 0x8f,
2159         0x76, 0x97, 0x2b, 0x77, 0x02, 0x2e, 0x38, 0x32, 0xe0, 0xed, 0x9d, 0xb4, 0x5d, 0xef, 0x6c, 0x39,
2160         0x2d, 0x74, 0x08, 0xee, 0x82, 0x6a, 0xbf, 0x9e, 0xc4, 0xc6, 0xee, 0xc3, 0xcb, 0x8a, 0x64, 0x33,
2161         0x09, 0xfe, 0x04, 0x35, 0x04, 0x1b, 0xc1, 0xa7, 0xe3, 0x31, 0x38, 0x52, 0xb4, 0x5f, 0x49, 0x5d,
2162         0x74, 0xd5, 0x7b, 0x79, 0x52, 0xc0, 0x17, 0xb1, 0x71, 0xbb, 0x38, 0x1e, 0xba, 0x54, 0x08, 0xb2,
2163         0x4a, 0xeb, 0xfe, 0xa6, 0xa1, 0x57, 0x5f, 0xf0, 0xb3, 0x30, 0x45, 0x55, 0x91, 0x3d, 0x41, 0xf9,
2164         0xec, 0x7f, 0xb0, 0xfd, 0xaf, 0xb8, 0xfc, 0x76, 0xd9, 0x8d, 0x24, 0x36, 0xaa, 0x0b, 0x74, 0xa1,
2165         0x8b, 0x7b, 0xa8, 0xe6, 0x50, 0x3b, 0xf2, 0x47, 0xf9, 0xe3, 0xd9, 0xb4, 0x9b, 0x6a, 0x57, 0x0e,
2166         0x0f, 0x32, 0x8c, 0x2c, 0xa3, 0xf8, 0x0d, 0x54, 0x8e, 0xb8, 0x9b, 0xbf, 0x53, 0xd5, 0x24, 0x36,
2167         0xca, 0x5f, 0x91, 0x63, 0xa2, 0x30, 0xfb, 0xde, 0xd9, 0xb9, 0x5e, 0x7a, 0x76, 0xae, 0x97, 0x9e,
2168         0x9f, 0xeb, 0xa5, 0x1f, 0x12, 0x5d, 0x3b, 0x4b, 0x74, 0xed, 0x59, 0xa2, 0x6b, 0xcf, 0x13, 0x5d,
2169         0xfb, 0x33, 0xd1, 0xb5, 0x9f, 0xfe, 0xd2, 0x4b, 0x5f, 0x57, 0xf3, 0xd2, 0xfe, 0x0d, 0x00, 0x00,
2170         0xff, 0xff, 0x85, 0x06, 0x8c, 0x7f, 0xae, 0x09, 0x00, 0x00,
2171 }