cmd/bpa-operator/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/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/apiextensions-apiserver/pkg/apis/apiextensions/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/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 ConversionRequest
  28                 ConversionResponse
  29                 ConversionReview
  30                 CustomResourceColumnDefinition
  31                 CustomResourceConversion
  32                 CustomResourceDefinition
  33                 CustomResourceDefinitionCondition
  34                 CustomResourceDefinitionList
  35                 CustomResourceDefinitionNames
  36                 CustomResourceDefinitionSpec
  37                 CustomResourceDefinitionStatus
  38                 CustomResourceDefinitionVersion
  39                 CustomResourceSubresourceScale
  40                 CustomResourceSubresourceStatus
  41                 CustomResourceSubresources
  42                 CustomResourceValidation
  43                 ExternalDocumentation
  44                 JSON
  45                 JSONSchemaProps
  46                 JSONSchemaPropsOrArray
  47                 JSONSchemaPropsOrBool
  48                 JSONSchemaPropsOrStringArray
  49                 ServiceReference
  50                 WebhookClientConfig
  51 */
  52 package v1beta1
  53
  54 import proto "github.com/gogo/protobuf/proto"
  55 import fmt "fmt"
  56 import math "math"
  57
  58 import k8s_io_apimachinery_pkg_runtime "k8s.io/apimachinery/pkg/runtime"
  59
  60 import k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
  61
  62 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  63 import encoding_binary "encoding/binary"
  64
  65 import strings "strings"
  66 import reflect "reflect"
  67
  68 import io "io"
  69
  70 // Reference imports to suppress errors if they are not otherwise used.
  71 var _ = proto.Marshal
  72 var _ = fmt.Errorf
  73 var _ = math.Inf
  74
  75 // This is a compile-time assertion to ensure that this generated file
  76 // is compatible with the proto package it is being compiled against.
  77 // A compilation error at this line likely means your copy of the
  78 // proto package needs to be updated.
  79 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  80
  81 func (m *ConversionRequest) Reset()                    { *m = ConversionRequest{} }
  82 func (*ConversionRequest) ProtoMessage()               {}
  83 func (*ConversionRequest) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  84
  85 func (m *ConversionResponse) Reset()                    { *m = ConversionResponse{} }
  86 func (*ConversionResponse) ProtoMessage()               {}
  87 func (*ConversionResponse) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  88
  89 func (m *ConversionReview) Reset()                    { *m = ConversionReview{} }
  90 func (*ConversionReview) ProtoMessage()               {}
  91 func (*ConversionReview) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  92
  93 func (m *CustomResourceColumnDefinition) Reset()      { *m = CustomResourceColumnDefinition{} }
  94 func (*CustomResourceColumnDefinition) ProtoMessage() {}
  95 func (*CustomResourceColumnDefinition) Descriptor() ([]byte, []int) {
  96         return fileDescriptorGenerated, []int{3}
  97 }
  98
  99 func (m *CustomResourceConversion) Reset()      { *m = CustomResourceConversion{} }
 100 func (*CustomResourceConversion) ProtoMessage() {}
 101 func (*CustomResourceConversion) Descriptor() ([]byte, []int) {
 102         return fileDescriptorGenerated, []int{4}
 103 }
 104
 105 func (m *CustomResourceDefinition) Reset()      { *m = CustomResourceDefinition{} }
 106 func (*CustomResourceDefinition) ProtoMessage() {}
 107 func (*CustomResourceDefinition) Descriptor() ([]byte, []int) {
 108         return fileDescriptorGenerated, []int{5}
 109 }
 110
 111 func (m *CustomResourceDefinitionCondition) Reset()      { *m = CustomResourceDefinitionCondition{} }
 112 func (*CustomResourceDefinitionCondition) ProtoMessage() {}
 113 func (*CustomResourceDefinitionCondition) Descriptor() ([]byte, []int) {
 114         return fileDescriptorGenerated, []int{6}
 115 }
 116
 117 func (m *CustomResourceDefinitionList) Reset()      { *m = CustomResourceDefinitionList{} }
 118 func (*CustomResourceDefinitionList) ProtoMessage() {}
 119 func (*CustomResourceDefinitionList) Descriptor() ([]byte, []int) {
 120         return fileDescriptorGenerated, []int{7}
 121 }
 122
 123 func (m *CustomResourceDefinitionNames) Reset()      { *m = CustomResourceDefinitionNames{} }
 124 func (*CustomResourceDefinitionNames) ProtoMessage() {}
 125 func (*CustomResourceDefinitionNames) Descriptor() ([]byte, []int) {
 126         return fileDescriptorGenerated, []int{8}
 127 }
 128
 129 func (m *CustomResourceDefinitionSpec) Reset()      { *m = CustomResourceDefinitionSpec{} }
 130 func (*CustomResourceDefinitionSpec) ProtoMessage() {}
 131 func (*CustomResourceDefinitionSpec) Descriptor() ([]byte, []int) {
 132         return fileDescriptorGenerated, []int{9}
 133 }
 134
 135 func (m *CustomResourceDefinitionStatus) Reset()      { *m = CustomResourceDefinitionStatus{} }
 136 func (*CustomResourceDefinitionStatus) ProtoMessage() {}
 137 func (*CustomResourceDefinitionStatus) Descriptor() ([]byte, []int) {
 138         return fileDescriptorGenerated, []int{10}
 139 }
 140
 141 func (m *CustomResourceDefinitionVersion) Reset()      { *m = CustomResourceDefinitionVersion{} }
 142 func (*CustomResourceDefinitionVersion) ProtoMessage() {}
 143 func (*CustomResourceDefinitionVersion) Descriptor() ([]byte, []int) {
 144         return fileDescriptorGenerated, []int{11}
 145 }
 146
 147 func (m *CustomResourceSubresourceScale) Reset()      { *m = CustomResourceSubresourceScale{} }
 148 func (*CustomResourceSubresourceScale) ProtoMessage() {}
 149 func (*CustomResourceSubresourceScale) Descriptor() ([]byte, []int) {
 150         return fileDescriptorGenerated, []int{12}
 151 }
 152
 153 func (m *CustomResourceSubresourceStatus) Reset()      { *m = CustomResourceSubresourceStatus{} }
 154 func (*CustomResourceSubresourceStatus) ProtoMessage() {}
 155 func (*CustomResourceSubresourceStatus) Descriptor() ([]byte, []int) {
 156         return fileDescriptorGenerated, []int{13}
 157 }
 158
 159 func (m *CustomResourceSubresources) Reset()      { *m = CustomResourceSubresources{} }
 160 func (*CustomResourceSubresources) ProtoMessage() {}
 161 func (*CustomResourceSubresources) Descriptor() ([]byte, []int) {
 162         return fileDescriptorGenerated, []int{14}
 163 }
 164
 165 func (m *CustomResourceValidation) Reset()      { *m = CustomResourceValidation{} }
 166 func (*CustomResourceValidation) ProtoMessage() {}
 167 func (*CustomResourceValidation) Descriptor() ([]byte, []int) {
 168         return fileDescriptorGenerated, []int{15}
 169 }
 170
 171 func (m *ExternalDocumentation) Reset()                    { *m = ExternalDocumentation{} }
 172 func (*ExternalDocumentation) ProtoMessage()               {}
 173 func (*ExternalDocumentation) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
 174
 175 func (m *JSON) Reset()                    { *m = JSON{} }
 176 func (*JSON) ProtoMessage()               {}
 177 func (*JSON) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
 178
 179 func (m *JSONSchemaProps) Reset()                    { *m = JSONSchemaProps{} }
 180 func (*JSONSchemaProps) ProtoMessage()               {}
 181 func (*JSONSchemaProps) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
 182
 183 func (m *JSONSchemaPropsOrArray) Reset()                    { *m = JSONSchemaPropsOrArray{} }
 184 func (*JSONSchemaPropsOrArray) ProtoMessage()               {}
 185 func (*JSONSchemaPropsOrArray) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
 186
 187 func (m *JSONSchemaPropsOrBool) Reset()                    { *m = JSONSchemaPropsOrBool{} }
 188 func (*JSONSchemaPropsOrBool) ProtoMessage()               {}
 189 func (*JSONSchemaPropsOrBool) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
 190
 191 func (m *JSONSchemaPropsOrStringArray) Reset()      { *m = JSONSchemaPropsOrStringArray{} }
 192 func (*JSONSchemaPropsOrStringArray) ProtoMessage() {}
 193 func (*JSONSchemaPropsOrStringArray) Descriptor() ([]byte, []int) {
 194         return fileDescriptorGenerated, []int{21}
 195 }
 196
 197 func (m *ServiceReference) Reset()                    { *m = ServiceReference{} }
 198 func (*ServiceReference) ProtoMessage()               {}
 199 func (*ServiceReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
 200
 201 func (m *WebhookClientConfig) Reset()                    { *m = WebhookClientConfig{} }
 202 func (*WebhookClientConfig) ProtoMessage()               {}
 203 func (*WebhookClientConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
 204
 205 func init() {
 206         proto.RegisterType((*ConversionRequest)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ConversionRequest")
 207         proto.RegisterType((*ConversionResponse)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ConversionResponse")
 208         proto.RegisterType((*ConversionReview)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ConversionReview")
 209         proto.RegisterType((*CustomResourceColumnDefinition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceColumnDefinition")
 210         proto.RegisterType((*CustomResourceConversion)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceConversion")
 211         proto.RegisterType((*CustomResourceDefinition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinition")
 212         proto.RegisterType((*CustomResourceDefinitionCondition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionCondition")
 213         proto.RegisterType((*CustomResourceDefinitionList)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionList")
 214         proto.RegisterType((*CustomResourceDefinitionNames)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionNames")
 215         proto.RegisterType((*CustomResourceDefinitionSpec)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionSpec")
 216         proto.RegisterType((*CustomResourceDefinitionStatus)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionStatus")
 217         proto.RegisterType((*CustomResourceDefinitionVersion)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionVersion")
 218         proto.RegisterType((*CustomResourceSubresourceScale)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresourceScale")
 219         proto.RegisterType((*CustomResourceSubresourceStatus)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresourceStatus")
 220         proto.RegisterType((*CustomResourceSubresources)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresources")
 221         proto.RegisterType((*CustomResourceValidation)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceValidation")
 222         proto.RegisterType((*ExternalDocumentation)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ExternalDocumentation")
 223         proto.RegisterType((*JSON)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSON")
 224         proto.RegisterType((*JSONSchemaProps)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps")
 225         proto.RegisterType((*JSONSchemaPropsOrArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrArray")
 226         proto.RegisterType((*JSONSchemaPropsOrBool)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrBool")
 227         proto.RegisterType((*JSONSchemaPropsOrStringArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrStringArray")
 228         proto.RegisterType((*ServiceReference)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ServiceReference")
 229         proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.WebhookClientConfig")
 230 }
 231 func (m *ConversionRequest) Marshal() (dAtA []byte, err error) {
 232         size := m.Size()
 233         dAtA = make([]byte, size)
 234         n, err := m.MarshalTo(dAtA)
 235         if err != nil {
 236                 return nil, err
 237         }
 238         return dAtA[:n], nil
 239 }
 240
 241 func (m *ConversionRequest) MarshalTo(dAtA []byte) (int, error) {
 242         var i int
 243         _ = i
 244         var l int
 245         _ = l
 246         dAtA[i] = 0xa
 247         i++
 248         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
 249         i += copy(dAtA[i:], m.UID)
 250         dAtA[i] = 0x12
 251         i++
 252         i = encodeVarintGenerated(dAtA, i, uint64(len(m.DesiredAPIVersion)))
 253         i += copy(dAtA[i:], m.DesiredAPIVersion)
 254         if len(m.Objects) > 0 {
 255                 for _, msg := range m.Objects {
 256                         dAtA[i] = 0x1a
 257                         i++
 258                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 259                         n, err := msg.MarshalTo(dAtA[i:])
 260                         if err != nil {
 261                                 return 0, err
 262                         }
 263                         i += n
 264                 }
 265         }
 266         return i, nil
 267 }
 268
 269 func (m *ConversionResponse) Marshal() (dAtA []byte, err error) {
 270         size := m.Size()
 271         dAtA = make([]byte, size)
 272         n, err := m.MarshalTo(dAtA)
 273         if err != nil {
 274                 return nil, err
 275         }
 276         return dAtA[:n], nil
 277 }
 278
 279 func (m *ConversionResponse) MarshalTo(dAtA []byte) (int, error) {
 280         var i int
 281         _ = i
 282         var l int
 283         _ = l
 284         dAtA[i] = 0xa
 285         i++
 286         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
 287         i += copy(dAtA[i:], m.UID)
 288         if len(m.ConvertedObjects) > 0 {
 289                 for _, msg := range m.ConvertedObjects {
 290                         dAtA[i] = 0x12
 291                         i++
 292                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 293                         n, err := msg.MarshalTo(dAtA[i:])
 294                         if err != nil {
 295                                 return 0, err
 296                         }
 297                         i += n
 298                 }
 299         }
 300         dAtA[i] = 0x1a
 301         i++
 302         i = encodeVarintGenerated(dAtA, i, uint64(m.Result.Size()))
 303         n1, err := m.Result.MarshalTo(dAtA[i:])
 304         if err != nil {
 305                 return 0, err
 306         }
 307         i += n1
 308         return i, nil
 309 }
 310
 311 func (m *ConversionReview) Marshal() (dAtA []byte, err error) {
 312         size := m.Size()
 313         dAtA = make([]byte, size)
 314         n, err := m.MarshalTo(dAtA)
 315         if err != nil {
 316                 return nil, err
 317         }
 318         return dAtA[:n], nil
 319 }
 320
 321 func (m *ConversionReview) MarshalTo(dAtA []byte) (int, error) {
 322         var i int
 323         _ = i
 324         var l int
 325         _ = l
 326         if m.Request != nil {
 327                 dAtA[i] = 0xa
 328                 i++
 329                 i = encodeVarintGenerated(dAtA, i, uint64(m.Request.Size()))
 330                 n2, err := m.Request.MarshalTo(dAtA[i:])
 331                 if err != nil {
 332                         return 0, err
 333                 }
 334                 i += n2
 335         }
 336         if m.Response != nil {
 337                 dAtA[i] = 0x12
 338                 i++
 339                 i = encodeVarintGenerated(dAtA, i, uint64(m.Response.Size()))
 340                 n3, err := m.Response.MarshalTo(dAtA[i:])
 341                 if err != nil {
 342                         return 0, err
 343                 }
 344                 i += n3
 345         }
 346         return i, nil
 347 }
 348
 349 func (m *CustomResourceColumnDefinition) Marshal() (dAtA []byte, err error) {
 350         size := m.Size()
 351         dAtA = make([]byte, size)
 352         n, err := m.MarshalTo(dAtA)
 353         if err != nil {
 354                 return nil, err
 355         }
 356         return dAtA[:n], nil
 357 }
 358
 359 func (m *CustomResourceColumnDefinition) MarshalTo(dAtA []byte) (int, error) {
 360         var i int
 361         _ = i
 362         var l int
 363         _ = l
 364         dAtA[i] = 0xa
 365         i++
 366         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 367         i += copy(dAtA[i:], m.Name)
 368         dAtA[i] = 0x12
 369         i++
 370         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 371         i += copy(dAtA[i:], m.Type)
 372         dAtA[i] = 0x1a
 373         i++
 374         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format)))
 375         i += copy(dAtA[i:], m.Format)
 376         dAtA[i] = 0x22
 377         i++
 378         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
 379         i += copy(dAtA[i:], m.Description)
 380         dAtA[i] = 0x28
 381         i++
 382         i = encodeVarintGenerated(dAtA, i, uint64(m.Priority))
 383         dAtA[i] = 0x32
 384         i++
 385         i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONPath)))
 386         i += copy(dAtA[i:], m.JSONPath)
 387         return i, nil
 388 }
 389
 390 func (m *CustomResourceConversion) Marshal() (dAtA []byte, err error) {
 391         size := m.Size()
 392         dAtA = make([]byte, size)
 393         n, err := m.MarshalTo(dAtA)
 394         if err != nil {
 395                 return nil, err
 396         }
 397         return dAtA[:n], nil
 398 }
 399
 400 func (m *CustomResourceConversion) MarshalTo(dAtA []byte) (int, error) {
 401         var i int
 402         _ = i
 403         var l int
 404         _ = l
 405         dAtA[i] = 0xa
 406         i++
 407         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Strategy)))
 408         i += copy(dAtA[i:], m.Strategy)
 409         if m.WebhookClientConfig != nil {
 410                 dAtA[i] = 0x12
 411                 i++
 412                 i = encodeVarintGenerated(dAtA, i, uint64(m.WebhookClientConfig.Size()))
 413                 n4, err := m.WebhookClientConfig.MarshalTo(dAtA[i:])
 414                 if err != nil {
 415                         return 0, err
 416                 }
 417                 i += n4
 418         }
 419         return i, nil
 420 }
 421
 422 func (m *CustomResourceDefinition) Marshal() (dAtA []byte, err error) {
 423         size := m.Size()
 424         dAtA = make([]byte, size)
 425         n, err := m.MarshalTo(dAtA)
 426         if err != nil {
 427                 return nil, err
 428         }
 429         return dAtA[:n], nil
 430 }
 431
 432 func (m *CustomResourceDefinition) MarshalTo(dAtA []byte) (int, error) {
 433         var i int
 434         _ = i
 435         var l int
 436         _ = l
 437         dAtA[i] = 0xa
 438         i++
 439         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 440         n5, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 441         if err != nil {
 442                 return 0, err
 443         }
 444         i += n5
 445         dAtA[i] = 0x12
 446         i++
 447         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 448         n6, err := m.Spec.MarshalTo(dAtA[i:])
 449         if err != nil {
 450                 return 0, err
 451         }
 452         i += n6
 453         dAtA[i] = 0x1a
 454         i++
 455         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 456         n7, err := m.Status.MarshalTo(dAtA[i:])
 457         if err != nil {
 458                 return 0, err
 459         }
 460         i += n7
 461         return i, nil
 462 }
 463
 464 func (m *CustomResourceDefinitionCondition) Marshal() (dAtA []byte, err error) {
 465         size := m.Size()
 466         dAtA = make([]byte, size)
 467         n, err := m.MarshalTo(dAtA)
 468         if err != nil {
 469                 return nil, err
 470         }
 471         return dAtA[:n], nil
 472 }
 473
 474 func (m *CustomResourceDefinitionCondition) MarshalTo(dAtA []byte) (int, error) {
 475         var i int
 476         _ = i
 477         var l int
 478         _ = l
 479         dAtA[i] = 0xa
 480         i++
 481         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 482         i += copy(dAtA[i:], m.Type)
 483         dAtA[i] = 0x12
 484         i++
 485         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
 486         i += copy(dAtA[i:], m.Status)
 487         dAtA[i] = 0x1a
 488         i++
 489         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
 490         n8, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
 491         if err != nil {
 492                 return 0, err
 493         }
 494         i += n8
 495         dAtA[i] = 0x22
 496         i++
 497         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 498         i += copy(dAtA[i:], m.Reason)
 499         dAtA[i] = 0x2a
 500         i++
 501         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 502         i += copy(dAtA[i:], m.Message)
 503         return i, nil
 504 }
 505
 506 func (m *CustomResourceDefinitionList) Marshal() (dAtA []byte, err error) {
 507         size := m.Size()
 508         dAtA = make([]byte, size)
 509         n, err := m.MarshalTo(dAtA)
 510         if err != nil {
 511                 return nil, err
 512         }
 513         return dAtA[:n], nil
 514 }
 515
 516 func (m *CustomResourceDefinitionList) MarshalTo(dAtA []byte) (int, error) {
 517         var i int
 518         _ = i
 519         var l int
 520         _ = l
 521         dAtA[i] = 0xa
 522         i++
 523         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 524         n9, err := m.ListMeta.MarshalTo(dAtA[i:])
 525         if err != nil {
 526                 return 0, err
 527         }
 528         i += n9
 529         if len(m.Items) > 0 {
 530                 for _, msg := range m.Items {
 531                         dAtA[i] = 0x12
 532                         i++
 533                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 534                         n, err := msg.MarshalTo(dAtA[i:])
 535                         if err != nil {
 536                                 return 0, err
 537                         }
 538                         i += n
 539                 }
 540         }
 541         return i, nil
 542 }
 543
 544 func (m *CustomResourceDefinitionNames) Marshal() (dAtA []byte, err error) {
 545         size := m.Size()
 546         dAtA = make([]byte, size)
 547         n, err := m.MarshalTo(dAtA)
 548         if err != nil {
 549                 return nil, err
 550         }
 551         return dAtA[:n], nil
 552 }
 553
 554 func (m *CustomResourceDefinitionNames) MarshalTo(dAtA []byte) (int, error) {
 555         var i int
 556         _ = i
 557         var l int
 558         _ = l
 559         dAtA[i] = 0xa
 560         i++
 561         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Plural)))
 562         i += copy(dAtA[i:], m.Plural)
 563         dAtA[i] = 0x12
 564         i++
 565         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Singular)))
 566         i += copy(dAtA[i:], m.Singular)
 567         if len(m.ShortNames) > 0 {
 568                 for _, s := range m.ShortNames {
 569                         dAtA[i] = 0x1a
 570                         i++
 571                         l = len(s)
 572                         for l >= 1<<7 {
 573                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 574                                 l >>= 7
 575                                 i++
 576                         }
 577                         dAtA[i] = uint8(l)
 578                         i++
 579                         i += copy(dAtA[i:], s)
 580                 }
 581         }
 582         dAtA[i] = 0x22
 583         i++
 584         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 585         i += copy(dAtA[i:], m.Kind)
 586         dAtA[i] = 0x2a
 587         i++
 588         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ListKind)))
 589         i += copy(dAtA[i:], m.ListKind)
 590         if len(m.Categories) > 0 {
 591                 for _, s := range m.Categories {
 592                         dAtA[i] = 0x32
 593                         i++
 594                         l = len(s)
 595                         for l >= 1<<7 {
 596                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 597                                 l >>= 7
 598                                 i++
 599                         }
 600                         dAtA[i] = uint8(l)
 601                         i++
 602                         i += copy(dAtA[i:], s)
 603                 }
 604         }
 605         return i, nil
 606 }
 607
 608 func (m *CustomResourceDefinitionSpec) Marshal() (dAtA []byte, err error) {
 609         size := m.Size()
 610         dAtA = make([]byte, size)
 611         n, err := m.MarshalTo(dAtA)
 612         if err != nil {
 613                 return nil, err
 614         }
 615         return dAtA[:n], nil
 616 }
 617
 618 func (m *CustomResourceDefinitionSpec) MarshalTo(dAtA []byte) (int, error) {
 619         var i int
 620         _ = i
 621         var l int
 622         _ = l
 623         dAtA[i] = 0xa
 624         i++
 625         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 626         i += copy(dAtA[i:], m.Group)
 627         dAtA[i] = 0x12
 628         i++
 629         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 630         i += copy(dAtA[i:], m.Version)
 631         dAtA[i] = 0x1a
 632         i++
 633         i = encodeVarintGenerated(dAtA, i, uint64(m.Names.Size()))
 634         n10, err := m.Names.MarshalTo(dAtA[i:])
 635         if err != nil {
 636                 return 0, err
 637         }
 638         i += n10
 639         dAtA[i] = 0x22
 640         i++
 641         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scope)))
 642         i += copy(dAtA[i:], m.Scope)
 643         if m.Validation != nil {
 644                 dAtA[i] = 0x2a
 645                 i++
 646                 i = encodeVarintGenerated(dAtA, i, uint64(m.Validation.Size()))
 647                 n11, err := m.Validation.MarshalTo(dAtA[i:])
 648                 if err != nil {
 649                         return 0, err
 650                 }
 651                 i += n11
 652         }
 653         if m.Subresources != nil {
 654                 dAtA[i] = 0x32
 655                 i++
 656                 i = encodeVarintGenerated(dAtA, i, uint64(m.Subresources.Size()))
 657                 n12, err := m.Subresources.MarshalTo(dAtA[i:])
 658                 if err != nil {
 659                         return 0, err
 660                 }
 661                 i += n12
 662         }
 663         if len(m.Versions) > 0 {
 664                 for _, msg := range m.Versions {
 665                         dAtA[i] = 0x3a
 666                         i++
 667                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 668                         n, err := msg.MarshalTo(dAtA[i:])
 669                         if err != nil {
 670                                 return 0, err
 671                         }
 672                         i += n
 673                 }
 674         }
 675         if len(m.AdditionalPrinterColumns) > 0 {
 676                 for _, msg := range m.AdditionalPrinterColumns {
 677                         dAtA[i] = 0x42
 678                         i++
 679                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 680                         n, err := msg.MarshalTo(dAtA[i:])
 681                         if err != nil {
 682                                 return 0, err
 683                         }
 684                         i += n
 685                 }
 686         }
 687         if m.Conversion != nil {
 688                 dAtA[i] = 0x4a
 689                 i++
 690                 i = encodeVarintGenerated(dAtA, i, uint64(m.Conversion.Size()))
 691                 n13, err := m.Conversion.MarshalTo(dAtA[i:])
 692                 if err != nil {
 693                         return 0, err
 694                 }
 695                 i += n13
 696         }
 697         return i, nil
 698 }
 699
 700 func (m *CustomResourceDefinitionStatus) Marshal() (dAtA []byte, err error) {
 701         size := m.Size()
 702         dAtA = make([]byte, size)
 703         n, err := m.MarshalTo(dAtA)
 704         if err != nil {
 705                 return nil, err
 706         }
 707         return dAtA[:n], nil
 708 }
 709
 710 func (m *CustomResourceDefinitionStatus) MarshalTo(dAtA []byte) (int, error) {
 711         var i int
 712         _ = i
 713         var l int
 714         _ = l
 715         if len(m.Conditions) > 0 {
 716                 for _, msg := range m.Conditions {
 717                         dAtA[i] = 0xa
 718                         i++
 719                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 720                         n, err := msg.MarshalTo(dAtA[i:])
 721                         if err != nil {
 722                                 return 0, err
 723                         }
 724                         i += n
 725                 }
 726         }
 727         dAtA[i] = 0x12
 728         i++
 729         i = encodeVarintGenerated(dAtA, i, uint64(m.AcceptedNames.Size()))
 730         n14, err := m.AcceptedNames.MarshalTo(dAtA[i:])
 731         if err != nil {
 732                 return 0, err
 733         }
 734         i += n14
 735         if len(m.StoredVersions) > 0 {
 736                 for _, s := range m.StoredVersions {
 737                         dAtA[i] = 0x1a
 738                         i++
 739                         l = len(s)
 740                         for l >= 1<<7 {
 741                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 742                                 l >>= 7
 743                                 i++
 744                         }
 745                         dAtA[i] = uint8(l)
 746                         i++
 747                         i += copy(dAtA[i:], s)
 748                 }
 749         }
 750         return i, nil
 751 }
 752
 753 func (m *CustomResourceDefinitionVersion) Marshal() (dAtA []byte, err error) {
 754         size := m.Size()
 755         dAtA = make([]byte, size)
 756         n, err := m.MarshalTo(dAtA)
 757         if err != nil {
 758                 return nil, err
 759         }
 760         return dAtA[:n], nil
 761 }
 762
 763 func (m *CustomResourceDefinitionVersion) MarshalTo(dAtA []byte) (int, error) {
 764         var i int
 765         _ = i
 766         var l int
 767         _ = l
 768         dAtA[i] = 0xa
 769         i++
 770         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 771         i += copy(dAtA[i:], m.Name)
 772         dAtA[i] = 0x10
 773         i++
 774         if m.Served {
 775                 dAtA[i] = 1
 776         } else {
 777                 dAtA[i] = 0
 778         }
 779         i++
 780         dAtA[i] = 0x18
 781         i++
 782         if m.Storage {
 783                 dAtA[i] = 1
 784         } else {
 785                 dAtA[i] = 0
 786         }
 787         i++
 788         if m.Schema != nil {
 789                 dAtA[i] = 0x22
 790                 i++
 791                 i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size()))
 792                 n15, err := m.Schema.MarshalTo(dAtA[i:])
 793                 if err != nil {
 794                         return 0, err
 795                 }
 796                 i += n15
 797         }
 798         if m.Subresources != nil {
 799                 dAtA[i] = 0x2a
 800                 i++
 801                 i = encodeVarintGenerated(dAtA, i, uint64(m.Subresources.Size()))
 802                 n16, err := m.Subresources.MarshalTo(dAtA[i:])
 803                 if err != nil {
 804                         return 0, err
 805                 }
 806                 i += n16
 807         }
 808         if len(m.AdditionalPrinterColumns) > 0 {
 809                 for _, msg := range m.AdditionalPrinterColumns {
 810                         dAtA[i] = 0x32
 811                         i++
 812                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 813                         n, err := msg.MarshalTo(dAtA[i:])
 814                         if err != nil {
 815                                 return 0, err
 816                         }
 817                         i += n
 818                 }
 819         }
 820         return i, nil
 821 }
 822
 823 func (m *CustomResourceSubresourceScale) Marshal() (dAtA []byte, err error) {
 824         size := m.Size()
 825         dAtA = make([]byte, size)
 826         n, err := m.MarshalTo(dAtA)
 827         if err != nil {
 828                 return nil, err
 829         }
 830         return dAtA[:n], nil
 831 }
 832
 833 func (m *CustomResourceSubresourceScale) MarshalTo(dAtA []byte) (int, error) {
 834         var i int
 835         _ = i
 836         var l int
 837         _ = l
 838         dAtA[i] = 0xa
 839         i++
 840         i = encodeVarintGenerated(dAtA, i, uint64(len(m.SpecReplicasPath)))
 841         i += copy(dAtA[i:], m.SpecReplicasPath)
 842         dAtA[i] = 0x12
 843         i++
 844         i = encodeVarintGenerated(dAtA, i, uint64(len(m.StatusReplicasPath)))
 845         i += copy(dAtA[i:], m.StatusReplicasPath)
 846         if m.LabelSelectorPath != nil {
 847                 dAtA[i] = 0x1a
 848                 i++
 849                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.LabelSelectorPath)))
 850                 i += copy(dAtA[i:], *m.LabelSelectorPath)
 851         }
 852         return i, nil
 853 }
 854
 855 func (m *CustomResourceSubresourceStatus) Marshal() (dAtA []byte, err error) {
 856         size := m.Size()
 857         dAtA = make([]byte, size)
 858         n, err := m.MarshalTo(dAtA)
 859         if err != nil {
 860                 return nil, err
 861         }
 862         return dAtA[:n], nil
 863 }
 864
 865 func (m *CustomResourceSubresourceStatus) MarshalTo(dAtA []byte) (int, error) {
 866         var i int
 867         _ = i
 868         var l int
 869         _ = l
 870         return i, nil
 871 }
 872
 873 func (m *CustomResourceSubresources) Marshal() (dAtA []byte, err error) {
 874         size := m.Size()
 875         dAtA = make([]byte, size)
 876         n, err := m.MarshalTo(dAtA)
 877         if err != nil {
 878                 return nil, err
 879         }
 880         return dAtA[:n], nil
 881 }
 882
 883 func (m *CustomResourceSubresources) MarshalTo(dAtA []byte) (int, error) {
 884         var i int
 885         _ = i
 886         var l int
 887         _ = l
 888         if m.Status != nil {
 889                 dAtA[i] = 0xa
 890                 i++
 891                 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 892                 n17, err := m.Status.MarshalTo(dAtA[i:])
 893                 if err != nil {
 894                         return 0, err
 895                 }
 896                 i += n17
 897         }
 898         if m.Scale != nil {
 899                 dAtA[i] = 0x12
 900                 i++
 901                 i = encodeVarintGenerated(dAtA, i, uint64(m.Scale.Size()))
 902                 n18, err := m.Scale.MarshalTo(dAtA[i:])
 903                 if err != nil {
 904                         return 0, err
 905                 }
 906                 i += n18
 907         }
 908         return i, nil
 909 }
 910
 911 func (m *CustomResourceValidation) Marshal() (dAtA []byte, err error) {
 912         size := m.Size()
 913         dAtA = make([]byte, size)
 914         n, err := m.MarshalTo(dAtA)
 915         if err != nil {
 916                 return nil, err
 917         }
 918         return dAtA[:n], nil
 919 }
 920
 921 func (m *CustomResourceValidation) MarshalTo(dAtA []byte) (int, error) {
 922         var i int
 923         _ = i
 924         var l int
 925         _ = l
 926         if m.OpenAPIV3Schema != nil {
 927                 dAtA[i] = 0xa
 928                 i++
 929                 i = encodeVarintGenerated(dAtA, i, uint64(m.OpenAPIV3Schema.Size()))
 930                 n19, err := m.OpenAPIV3Schema.MarshalTo(dAtA[i:])
 931                 if err != nil {
 932                         return 0, err
 933                 }
 934                 i += n19
 935         }
 936         return i, nil
 937 }
 938
 939 func (m *ExternalDocumentation) Marshal() (dAtA []byte, err error) {
 940         size := m.Size()
 941         dAtA = make([]byte, size)
 942         n, err := m.MarshalTo(dAtA)
 943         if err != nil {
 944                 return nil, err
 945         }
 946         return dAtA[:n], nil
 947 }
 948
 949 func (m *ExternalDocumentation) MarshalTo(dAtA []byte) (int, error) {
 950         var i int
 951         _ = i
 952         var l int
 953         _ = l
 954         dAtA[i] = 0xa
 955         i++
 956         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
 957         i += copy(dAtA[i:], m.Description)
 958         dAtA[i] = 0x12
 959         i++
 960         i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
 961         i += copy(dAtA[i:], m.URL)
 962         return i, nil
 963 }
 964
 965 func (m *JSON) Marshal() (dAtA []byte, err error) {
 966         size := m.Size()
 967         dAtA = make([]byte, size)
 968         n, err := m.MarshalTo(dAtA)
 969         if err != nil {
 970                 return nil, err
 971         }
 972         return dAtA[:n], nil
 973 }
 974
 975 func (m *JSON) MarshalTo(dAtA []byte) (int, error) {
 976         var i int
 977         _ = i
 978         var l int
 979         _ = l
 980         if m.Raw != nil {
 981                 dAtA[i] = 0xa
 982                 i++
 983                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw)))
 984                 i += copy(dAtA[i:], m.Raw)
 985         }
 986         return i, nil
 987 }
 988
 989 func (m *JSONSchemaProps) Marshal() (dAtA []byte, err error) {
 990         size := m.Size()
 991         dAtA = make([]byte, size)
 992         n, err := m.MarshalTo(dAtA)
 993         if err != nil {
 994                 return nil, err
 995         }
 996         return dAtA[:n], nil
 997 }
 998
 999 func (m *JSONSchemaProps) MarshalTo(dAtA []byte) (int, error) {
1000         var i int
1001         _ = i
1002         var l int
1003         _ = l
1004         dAtA[i] = 0xa
1005         i++
1006         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ID)))
1007         i += copy(dAtA[i:], m.ID)
1008         dAtA[i] = 0x12
1009         i++
1010         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Schema)))
1011         i += copy(dAtA[i:], m.Schema)
1012         if m.Ref != nil {
1013                 dAtA[i] = 0x1a
1014                 i++
1015                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Ref)))
1016                 i += copy(dAtA[i:], *m.Ref)
1017         }
1018         dAtA[i] = 0x22
1019         i++
1020         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
1021         i += copy(dAtA[i:], m.Description)
1022         dAtA[i] = 0x2a
1023         i++
1024         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1025         i += copy(dAtA[i:], m.Type)
1026         dAtA[i] = 0x32
1027         i++
1028         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format)))
1029         i += copy(dAtA[i:], m.Format)
1030         dAtA[i] = 0x3a
1031         i++
1032         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Title)))
1033         i += copy(dAtA[i:], m.Title)
1034         if m.Default != nil {
1035                 dAtA[i] = 0x42
1036                 i++
1037                 i = encodeVarintGenerated(dAtA, i, uint64(m.Default.Size()))
1038                 n20, err := m.Default.MarshalTo(dAtA[i:])
1039                 if err != nil {
1040                         return 0, err
1041                 }
1042                 i += n20
1043         }
1044         if m.Maximum != nil {
1045                 dAtA[i] = 0x49
1046                 i++
1047                 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Maximum))))
1048                 i += 8
1049         }
1050         dAtA[i] = 0x50
1051         i++
1052         if m.ExclusiveMaximum {
1053                 dAtA[i] = 1
1054         } else {
1055                 dAtA[i] = 0
1056         }
1057         i++
1058         if m.Minimum != nil {
1059                 dAtA[i] = 0x59
1060                 i++
1061                 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Minimum))))
1062                 i += 8
1063         }
1064         dAtA[i] = 0x60
1065         i++
1066         if m.ExclusiveMinimum {
1067                 dAtA[i] = 1
1068         } else {
1069                 dAtA[i] = 0
1070         }
1071         i++
1072         if m.MaxLength != nil {
1073                 dAtA[i] = 0x68
1074                 i++
1075                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxLength))
1076         }
1077         if m.MinLength != nil {
1078                 dAtA[i] = 0x70
1079                 i++
1080                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinLength))
1081         }
1082         dAtA[i] = 0x7a
1083         i++
1084         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Pattern)))
1085         i += copy(dAtA[i:], m.Pattern)
1086         if m.MaxItems != nil {
1087                 dAtA[i] = 0x80
1088                 i++
1089                 dAtA[i] = 0x1
1090                 i++
1091                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxItems))
1092         }
1093         if m.MinItems != nil {
1094                 dAtA[i] = 0x88
1095                 i++
1096                 dAtA[i] = 0x1
1097                 i++
1098                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinItems))
1099         }
1100         dAtA[i] = 0x90
1101         i++
1102         dAtA[i] = 0x1
1103         i++
1104         if m.UniqueItems {
1105                 dAtA[i] = 1
1106         } else {
1107                 dAtA[i] = 0
1108         }
1109         i++
1110         if m.MultipleOf != nil {
1111                 dAtA[i] = 0x99
1112                 i++
1113                 dAtA[i] = 0x1
1114                 i++
1115                 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.MultipleOf))))
1116                 i += 8
1117         }
1118         if len(m.Enum) > 0 {
1119                 for _, msg := range m.Enum {
1120                         dAtA[i] = 0xa2
1121                         i++
1122                         dAtA[i] = 0x1
1123                         i++
1124                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1125                         n, err := msg.MarshalTo(dAtA[i:])
1126                         if err != nil {
1127                                 return 0, err
1128                         }
1129                         i += n
1130                 }
1131         }
1132         if m.MaxProperties != nil {
1133                 dAtA[i] = 0xa8
1134                 i++
1135                 dAtA[i] = 0x1
1136                 i++
1137                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxProperties))
1138         }
1139         if m.MinProperties != nil {
1140                 dAtA[i] = 0xb0
1141                 i++
1142                 dAtA[i] = 0x1
1143                 i++
1144                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinProperties))
1145         }
1146         if len(m.Required) > 0 {
1147                 for _, s := range m.Required {
1148                         dAtA[i] = 0xba
1149                         i++
1150                         dAtA[i] = 0x1
1151                         i++
1152                         l = len(s)
1153                         for l >= 1<<7 {
1154                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1155                                 l >>= 7
1156                                 i++
1157                         }
1158                         dAtA[i] = uint8(l)
1159                         i++
1160                         i += copy(dAtA[i:], s)
1161                 }
1162         }
1163         if m.Items != nil {
1164                 dAtA[i] = 0xc2
1165                 i++
1166                 dAtA[i] = 0x1
1167                 i++
1168                 i = encodeVarintGenerated(dAtA, i, uint64(m.Items.Size()))
1169                 n21, err := m.Items.MarshalTo(dAtA[i:])
1170                 if err != nil {
1171                         return 0, err
1172                 }
1173                 i += n21
1174         }
1175         if len(m.AllOf) > 0 {
1176                 for _, msg := range m.AllOf {
1177                         dAtA[i] = 0xca
1178                         i++
1179                         dAtA[i] = 0x1
1180                         i++
1181                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1182                         n, err := msg.MarshalTo(dAtA[i:])
1183                         if err != nil {
1184                                 return 0, err
1185                         }
1186                         i += n
1187                 }
1188         }
1189         if len(m.OneOf) > 0 {
1190                 for _, msg := range m.OneOf {
1191                         dAtA[i] = 0xd2
1192                         i++
1193                         dAtA[i] = 0x1
1194                         i++
1195                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1196                         n, err := msg.MarshalTo(dAtA[i:])
1197                         if err != nil {
1198                                 return 0, err
1199                         }
1200                         i += n
1201                 }
1202         }
1203         if len(m.AnyOf) > 0 {
1204                 for _, msg := range m.AnyOf {
1205                         dAtA[i] = 0xda
1206                         i++
1207                         dAtA[i] = 0x1
1208                         i++
1209                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1210                         n, err := msg.MarshalTo(dAtA[i:])
1211                         if err != nil {
1212                                 return 0, err
1213                         }
1214                         i += n
1215                 }
1216         }
1217         if m.Not != nil {
1218                 dAtA[i] = 0xe2
1219                 i++
1220                 dAtA[i] = 0x1
1221                 i++
1222                 i = encodeVarintGenerated(dAtA, i, uint64(m.Not.Size()))
1223                 n22, err := m.Not.MarshalTo(dAtA[i:])
1224                 if err != nil {
1225                         return 0, err
1226                 }
1227                 i += n22
1228         }
1229         if len(m.Properties) > 0 {
1230                 keysForProperties := make([]string, 0, len(m.Properties))
1231                 for k := range m.Properties {
1232                         keysForProperties = append(keysForProperties, string(k))
1233                 }
1234                 github_com_gogo_protobuf_sortkeys.Strings(keysForProperties)
1235                 for _, k := range keysForProperties {
1236                         dAtA[i] = 0xea
1237                         i++
1238                         dAtA[i] = 0x1
1239                         i++
1240                         v := m.Properties[string(k)]
1241                         msgSize := 0
1242                         if (&v) != nil {
1243                                 msgSize = (&v).Size()
1244                                 msgSize += 1 + sovGenerated(uint64(msgSize))
1245                         }
1246                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
1247                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1248                         dAtA[i] = 0xa
1249                         i++
1250                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1251                         i += copy(dAtA[i:], k)
1252                         dAtA[i] = 0x12
1253                         i++
1254                         i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
1255                         n23, err := (&v).MarshalTo(dAtA[i:])
1256                         if err != nil {
1257                                 return 0, err
1258                         }
1259                         i += n23
1260                 }
1261         }
1262         if m.AdditionalProperties != nil {
1263                 dAtA[i] = 0xf2
1264                 i++
1265                 dAtA[i] = 0x1
1266                 i++
1267                 i = encodeVarintGenerated(dAtA, i, uint64(m.AdditionalProperties.Size()))
1268                 n24, err := m.AdditionalProperties.MarshalTo(dAtA[i:])
1269                 if err != nil {
1270                         return 0, err
1271                 }
1272                 i += n24
1273         }
1274         if len(m.PatternProperties) > 0 {
1275                 keysForPatternProperties := make([]string, 0, len(m.PatternProperties))
1276                 for k := range m.PatternProperties {
1277                         keysForPatternProperties = append(keysForPatternProperties, string(k))
1278                 }
1279                 github_com_gogo_protobuf_sortkeys.Strings(keysForPatternProperties)
1280                 for _, k := range keysForPatternProperties {
1281                         dAtA[i] = 0xfa
1282                         i++
1283                         dAtA[i] = 0x1
1284                         i++
1285                         v := m.PatternProperties[string(k)]
1286                         msgSize := 0
1287                         if (&v) != nil {
1288                                 msgSize = (&v).Size()
1289                                 msgSize += 1 + sovGenerated(uint64(msgSize))
1290                         }
1291                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
1292                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1293                         dAtA[i] = 0xa
1294                         i++
1295                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1296                         i += copy(dAtA[i:], k)
1297                         dAtA[i] = 0x12
1298                         i++
1299                         i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
1300                         n25, err := (&v).MarshalTo(dAtA[i:])
1301                         if err != nil {
1302                                 return 0, err
1303                         }
1304                         i += n25
1305                 }
1306         }
1307         if len(m.Dependencies) > 0 {
1308                 keysForDependencies := make([]string, 0, len(m.Dependencies))
1309                 for k := range m.Dependencies {
1310                         keysForDependencies = append(keysForDependencies, string(k))
1311                 }
1312                 github_com_gogo_protobuf_sortkeys.Strings(keysForDependencies)
1313                 for _, k := range keysForDependencies {
1314                         dAtA[i] = 0x82
1315                         i++
1316                         dAtA[i] = 0x2
1317                         i++
1318                         v := m.Dependencies[string(k)]
1319                         msgSize := 0
1320                         if (&v) != nil {
1321                                 msgSize = (&v).Size()
1322                                 msgSize += 1 + sovGenerated(uint64(msgSize))
1323                         }
1324                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
1325                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1326                         dAtA[i] = 0xa
1327                         i++
1328                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1329                         i += copy(dAtA[i:], k)
1330                         dAtA[i] = 0x12
1331                         i++
1332                         i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
1333                         n26, err := (&v).MarshalTo(dAtA[i:])
1334                         if err != nil {
1335                                 return 0, err
1336                         }
1337                         i += n26
1338                 }
1339         }
1340         if m.AdditionalItems != nil {
1341                 dAtA[i] = 0x8a
1342                 i++
1343                 dAtA[i] = 0x2
1344                 i++
1345                 i = encodeVarintGenerated(dAtA, i, uint64(m.AdditionalItems.Size()))
1346                 n27, err := m.AdditionalItems.MarshalTo(dAtA[i:])
1347                 if err != nil {
1348                         return 0, err
1349                 }
1350                 i += n27
1351         }
1352         if len(m.Definitions) > 0 {
1353                 keysForDefinitions := make([]string, 0, len(m.Definitions))
1354                 for k := range m.Definitions {
1355                         keysForDefinitions = append(keysForDefinitions, string(k))
1356                 }
1357                 github_com_gogo_protobuf_sortkeys.Strings(keysForDefinitions)
1358                 for _, k := range keysForDefinitions {
1359                         dAtA[i] = 0x92
1360                         i++
1361                         dAtA[i] = 0x2
1362                         i++
1363                         v := m.Definitions[string(k)]
1364                         msgSize := 0
1365                         if (&v) != nil {
1366                                 msgSize = (&v).Size()
1367                                 msgSize += 1 + sovGenerated(uint64(msgSize))
1368                         }
1369                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
1370                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1371                         dAtA[i] = 0xa
1372                         i++
1373                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1374                         i += copy(dAtA[i:], k)
1375                         dAtA[i] = 0x12
1376                         i++
1377                         i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
1378                         n28, err := (&v).MarshalTo(dAtA[i:])
1379                         if err != nil {
1380                                 return 0, err
1381                         }
1382                         i += n28
1383                 }
1384         }
1385         if m.ExternalDocs != nil {
1386                 dAtA[i] = 0x9a
1387                 i++
1388                 dAtA[i] = 0x2
1389                 i++
1390                 i = encodeVarintGenerated(dAtA, i, uint64(m.ExternalDocs.Size()))
1391                 n29, err := m.ExternalDocs.MarshalTo(dAtA[i:])
1392                 if err != nil {
1393                         return 0, err
1394                 }
1395                 i += n29
1396         }
1397         if m.Example != nil {
1398                 dAtA[i] = 0xa2
1399                 i++
1400                 dAtA[i] = 0x2
1401                 i++
1402                 i = encodeVarintGenerated(dAtA, i, uint64(m.Example.Size()))
1403                 n30, err := m.Example.MarshalTo(dAtA[i:])
1404                 if err != nil {
1405                         return 0, err
1406                 }
1407                 i += n30
1408         }
1409         return i, nil
1410 }
1411
1412 func (m *JSONSchemaPropsOrArray) Marshal() (dAtA []byte, err error) {
1413         size := m.Size()
1414         dAtA = make([]byte, size)
1415         n, err := m.MarshalTo(dAtA)
1416         if err != nil {
1417                 return nil, err
1418         }
1419         return dAtA[:n], nil
1420 }
1421
1422 func (m *JSONSchemaPropsOrArray) MarshalTo(dAtA []byte) (int, error) {
1423         var i int
1424         _ = i
1425         var l int
1426         _ = l
1427         if m.Schema != nil {
1428                 dAtA[i] = 0xa
1429                 i++
1430                 i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size()))
1431                 n31, err := m.Schema.MarshalTo(dAtA[i:])
1432                 if err != nil {
1433                         return 0, err
1434                 }
1435                 i += n31
1436         }
1437         if len(m.JSONSchemas) > 0 {
1438                 for _, msg := range m.JSONSchemas {
1439                         dAtA[i] = 0x12
1440                         i++
1441                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1442                         n, err := msg.MarshalTo(dAtA[i:])
1443                         if err != nil {
1444                                 return 0, err
1445                         }
1446                         i += n
1447                 }
1448         }
1449         return i, nil
1450 }
1451
1452 func (m *JSONSchemaPropsOrBool) Marshal() (dAtA []byte, err error) {
1453         size := m.Size()
1454         dAtA = make([]byte, size)
1455         n, err := m.MarshalTo(dAtA)
1456         if err != nil {
1457                 return nil, err
1458         }
1459         return dAtA[:n], nil
1460 }
1461
1462 func (m *JSONSchemaPropsOrBool) MarshalTo(dAtA []byte) (int, error) {
1463         var i int
1464         _ = i
1465         var l int
1466         _ = l
1467         dAtA[i] = 0x8
1468         i++
1469         if m.Allows {
1470                 dAtA[i] = 1
1471         } else {
1472                 dAtA[i] = 0
1473         }
1474         i++
1475         if m.Schema != nil {
1476                 dAtA[i] = 0x12
1477                 i++
1478                 i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size()))
1479                 n32, err := m.Schema.MarshalTo(dAtA[i:])
1480                 if err != nil {
1481                         return 0, err
1482                 }
1483                 i += n32
1484         }
1485         return i, nil
1486 }
1487
1488 func (m *JSONSchemaPropsOrStringArray) Marshal() (dAtA []byte, err error) {
1489         size := m.Size()
1490         dAtA = make([]byte, size)
1491         n, err := m.MarshalTo(dAtA)
1492         if err != nil {
1493                 return nil, err
1494         }
1495         return dAtA[:n], nil
1496 }
1497
1498 func (m *JSONSchemaPropsOrStringArray) MarshalTo(dAtA []byte) (int, error) {
1499         var i int
1500         _ = i
1501         var l int
1502         _ = l
1503         if m.Schema != nil {
1504                 dAtA[i] = 0xa
1505                 i++
1506                 i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size()))
1507                 n33, err := m.Schema.MarshalTo(dAtA[i:])
1508                 if err != nil {
1509                         return 0, err
1510                 }
1511                 i += n33
1512         }
1513         if len(m.Property) > 0 {
1514                 for _, s := range m.Property {
1515                         dAtA[i] = 0x12
1516                         i++
1517                         l = len(s)
1518                         for l >= 1<<7 {
1519                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1520                                 l >>= 7
1521                                 i++
1522                         }
1523                         dAtA[i] = uint8(l)
1524                         i++
1525                         i += copy(dAtA[i:], s)
1526                 }
1527         }
1528         return i, nil
1529 }
1530
1531 func (m *ServiceReference) Marshal() (dAtA []byte, err error) {
1532         size := m.Size()
1533         dAtA = make([]byte, size)
1534         n, err := m.MarshalTo(dAtA)
1535         if err != nil {
1536                 return nil, err
1537         }
1538         return dAtA[:n], nil
1539 }
1540
1541 func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
1542         var i int
1543         _ = i
1544         var l int
1545         _ = l
1546         dAtA[i] = 0xa
1547         i++
1548         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
1549         i += copy(dAtA[i:], m.Namespace)
1550         dAtA[i] = 0x12
1551         i++
1552         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1553         i += copy(dAtA[i:], m.Name)
1554         if m.Path != nil {
1555                 dAtA[i] = 0x1a
1556                 i++
1557                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Path)))
1558                 i += copy(dAtA[i:], *m.Path)
1559         }
1560         return i, nil
1561 }
1562
1563 func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) {
1564         size := m.Size()
1565         dAtA = make([]byte, size)
1566         n, err := m.MarshalTo(dAtA)
1567         if err != nil {
1568                 return nil, err
1569         }
1570         return dAtA[:n], nil
1571 }
1572
1573 func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
1574         var i int
1575         _ = i
1576         var l int
1577         _ = l
1578         if m.Service != nil {
1579                 dAtA[i] = 0xa
1580                 i++
1581                 i = encodeVarintGenerated(dAtA, i, uint64(m.Service.Size()))
1582                 n34, err := m.Service.MarshalTo(dAtA[i:])
1583                 if err != nil {
1584                         return 0, err
1585                 }
1586                 i += n34
1587         }
1588         if m.CABundle != nil {
1589                 dAtA[i] = 0x12
1590                 i++
1591                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CABundle)))
1592                 i += copy(dAtA[i:], m.CABundle)
1593         }
1594         if m.URL != nil {
1595                 dAtA[i] = 0x1a
1596                 i++
1597                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.URL)))
1598                 i += copy(dAtA[i:], *m.URL)
1599         }
1600         return i, nil
1601 }
1602
1603 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1604         for v >= 1<<7 {
1605                 dAtA[offset] = uint8(v&0x7f | 0x80)
1606                 v >>= 7
1607                 offset++
1608         }
1609         dAtA[offset] = uint8(v)
1610         return offset + 1
1611 }
1612 func (m *ConversionRequest) Size() (n int) {
1613         var l int
1614         _ = l
1615         l = len(m.UID)
1616         n += 1 + l + sovGenerated(uint64(l))
1617         l = len(m.DesiredAPIVersion)
1618         n += 1 + l + sovGenerated(uint64(l))
1619         if len(m.Objects) > 0 {
1620                 for _, e := range m.Objects {
1621                         l = e.Size()
1622                         n += 1 + l + sovGenerated(uint64(l))
1623                 }
1624         }
1625         return n
1626 }
1627
1628 func (m *ConversionResponse) Size() (n int) {
1629         var l int
1630         _ = l
1631         l = len(m.UID)
1632         n += 1 + l + sovGenerated(uint64(l))
1633         if len(m.ConvertedObjects) > 0 {
1634                 for _, e := range m.ConvertedObjects {
1635                         l = e.Size()
1636                         n += 1 + l + sovGenerated(uint64(l))
1637                 }
1638         }
1639         l = m.Result.Size()
1640         n += 1 + l + sovGenerated(uint64(l))
1641         return n
1642 }
1643
1644 func (m *ConversionReview) Size() (n int) {
1645         var l int
1646         _ = l
1647         if m.Request != nil {
1648                 l = m.Request.Size()
1649                 n += 1 + l + sovGenerated(uint64(l))
1650         }
1651         if m.Response != nil {
1652                 l = m.Response.Size()
1653                 n += 1 + l + sovGenerated(uint64(l))
1654         }
1655         return n
1656 }
1657
1658 func (m *CustomResourceColumnDefinition) Size() (n int) {
1659         var l int
1660         _ = l
1661         l = len(m.Name)
1662         n += 1 + l + sovGenerated(uint64(l))
1663         l = len(m.Type)
1664         n += 1 + l + sovGenerated(uint64(l))
1665         l = len(m.Format)
1666         n += 1 + l + sovGenerated(uint64(l))
1667         l = len(m.Description)
1668         n += 1 + l + sovGenerated(uint64(l))
1669         n += 1 + sovGenerated(uint64(m.Priority))
1670         l = len(m.JSONPath)
1671         n += 1 + l + sovGenerated(uint64(l))
1672         return n
1673 }
1674
1675 func (m *CustomResourceConversion) Size() (n int) {
1676         var l int
1677         _ = l
1678         l = len(m.Strategy)
1679         n += 1 + l + sovGenerated(uint64(l))
1680         if m.WebhookClientConfig != nil {
1681                 l = m.WebhookClientConfig.Size()
1682                 n += 1 + l + sovGenerated(uint64(l))
1683         }
1684         return n
1685 }
1686
1687 func (m *CustomResourceDefinition) Size() (n int) {
1688         var l int
1689         _ = l
1690         l = m.ObjectMeta.Size()
1691         n += 1 + l + sovGenerated(uint64(l))
1692         l = m.Spec.Size()
1693         n += 1 + l + sovGenerated(uint64(l))
1694         l = m.Status.Size()
1695         n += 1 + l + sovGenerated(uint64(l))
1696         return n
1697 }
1698
1699 func (m *CustomResourceDefinitionCondition) Size() (n int) {
1700         var l int
1701         _ = l
1702         l = len(m.Type)
1703         n += 1 + l + sovGenerated(uint64(l))
1704         l = len(m.Status)
1705         n += 1 + l + sovGenerated(uint64(l))
1706         l = m.LastTransitionTime.Size()
1707         n += 1 + l + sovGenerated(uint64(l))
1708         l = len(m.Reason)
1709         n += 1 + l + sovGenerated(uint64(l))
1710         l = len(m.Message)
1711         n += 1 + l + sovGenerated(uint64(l))
1712         return n
1713 }
1714
1715 func (m *CustomResourceDefinitionList) Size() (n int) {
1716         var l int
1717         _ = l
1718         l = m.ListMeta.Size()
1719         n += 1 + l + sovGenerated(uint64(l))
1720         if len(m.Items) > 0 {
1721                 for _, e := range m.Items {
1722                         l = e.Size()
1723                         n += 1 + l + sovGenerated(uint64(l))
1724                 }
1725         }
1726         return n
1727 }
1728
1729 func (m *CustomResourceDefinitionNames) Size() (n int) {
1730         var l int
1731         _ = l
1732         l = len(m.Plural)
1733         n += 1 + l + sovGenerated(uint64(l))
1734         l = len(m.Singular)
1735         n += 1 + l + sovGenerated(uint64(l))
1736         if len(m.ShortNames) > 0 {
1737                 for _, s := range m.ShortNames {
1738                         l = len(s)
1739                         n += 1 + l + sovGenerated(uint64(l))
1740                 }
1741         }
1742         l = len(m.Kind)
1743         n += 1 + l + sovGenerated(uint64(l))
1744         l = len(m.ListKind)
1745         n += 1 + l + sovGenerated(uint64(l))
1746         if len(m.Categories) > 0 {
1747                 for _, s := range m.Categories {
1748                         l = len(s)
1749                         n += 1 + l + sovGenerated(uint64(l))
1750                 }
1751         }
1752         return n
1753 }
1754
1755 func (m *CustomResourceDefinitionSpec) Size() (n int) {
1756         var l int
1757         _ = l
1758         l = len(m.Group)
1759         n += 1 + l + sovGenerated(uint64(l))
1760         l = len(m.Version)
1761         n += 1 + l + sovGenerated(uint64(l))
1762         l = m.Names.Size()
1763         n += 1 + l + sovGenerated(uint64(l))
1764         l = len(m.Scope)
1765         n += 1 + l + sovGenerated(uint64(l))
1766         if m.Validation != nil {
1767                 l = m.Validation.Size()
1768                 n += 1 + l + sovGenerated(uint64(l))
1769         }
1770         if m.Subresources != nil {
1771                 l = m.Subresources.Size()
1772                 n += 1 + l + sovGenerated(uint64(l))
1773         }
1774         if len(m.Versions) > 0 {
1775                 for _, e := range m.Versions {
1776                         l = e.Size()
1777                         n += 1 + l + sovGenerated(uint64(l))
1778                 }
1779         }
1780         if len(m.AdditionalPrinterColumns) > 0 {
1781                 for _, e := range m.AdditionalPrinterColumns {
1782                         l = e.Size()
1783                         n += 1 + l + sovGenerated(uint64(l))
1784                 }
1785         }
1786         if m.Conversion != nil {
1787                 l = m.Conversion.Size()
1788                 n += 1 + l + sovGenerated(uint64(l))
1789         }
1790         return n
1791 }
1792
1793 func (m *CustomResourceDefinitionStatus) Size() (n int) {
1794         var l int
1795         _ = l
1796         if len(m.Conditions) > 0 {
1797                 for _, e := range m.Conditions {
1798                         l = e.Size()
1799                         n += 1 + l + sovGenerated(uint64(l))
1800                 }
1801         }
1802         l = m.AcceptedNames.Size()
1803         n += 1 + l + sovGenerated(uint64(l))
1804         if len(m.StoredVersions) > 0 {
1805                 for _, s := range m.StoredVersions {
1806                         l = len(s)
1807                         n += 1 + l + sovGenerated(uint64(l))
1808                 }
1809         }
1810         return n
1811 }
1812
1813 func (m *CustomResourceDefinitionVersion) Size() (n int) {
1814         var l int
1815         _ = l
1816         l = len(m.Name)
1817         n += 1 + l + sovGenerated(uint64(l))
1818         n += 2
1819         n += 2
1820         if m.Schema != nil {
1821                 l = m.Schema.Size()
1822                 n += 1 + l + sovGenerated(uint64(l))
1823         }
1824         if m.Subresources != nil {
1825                 l = m.Subresources.Size()
1826                 n += 1 + l + sovGenerated(uint64(l))
1827         }
1828         if len(m.AdditionalPrinterColumns) > 0 {
1829                 for _, e := range m.AdditionalPrinterColumns {
1830                         l = e.Size()
1831                         n += 1 + l + sovGenerated(uint64(l))
1832                 }
1833         }
1834         return n
1835 }
1836
1837 func (m *CustomResourceSubresourceScale) Size() (n int) {
1838         var l int
1839         _ = l
1840         l = len(m.SpecReplicasPath)
1841         n += 1 + l + sovGenerated(uint64(l))
1842         l = len(m.StatusReplicasPath)
1843         n += 1 + l + sovGenerated(uint64(l))
1844         if m.LabelSelectorPath != nil {
1845                 l = len(*m.LabelSelectorPath)
1846                 n += 1 + l + sovGenerated(uint64(l))
1847         }
1848         return n
1849 }
1850
1851 func (m *CustomResourceSubresourceStatus) Size() (n int) {
1852         var l int
1853         _ = l
1854         return n
1855 }
1856
1857 func (m *CustomResourceSubresources) Size() (n int) {
1858         var l int
1859         _ = l
1860         if m.Status != nil {
1861                 l = m.Status.Size()
1862                 n += 1 + l + sovGenerated(uint64(l))
1863         }
1864         if m.Scale != nil {
1865                 l = m.Scale.Size()
1866                 n += 1 + l + sovGenerated(uint64(l))
1867         }
1868         return n
1869 }
1870
1871 func (m *CustomResourceValidation) Size() (n int) {
1872         var l int
1873         _ = l
1874         if m.OpenAPIV3Schema != nil {
1875                 l = m.OpenAPIV3Schema.Size()
1876                 n += 1 + l + sovGenerated(uint64(l))
1877         }
1878         return n
1879 }
1880
1881 func (m *ExternalDocumentation) Size() (n int) {
1882         var l int
1883         _ = l
1884         l = len(m.Description)
1885         n += 1 + l + sovGenerated(uint64(l))
1886         l = len(m.URL)
1887         n += 1 + l + sovGenerated(uint64(l))
1888         return n
1889 }
1890
1891 func (m *JSON) Size() (n int) {
1892         var l int
1893         _ = l
1894         if m.Raw != nil {
1895                 l = len(m.Raw)
1896                 n += 1 + l + sovGenerated(uint64(l))
1897         }
1898         return n
1899 }
1900
1901 func (m *JSONSchemaProps) Size() (n int) {
1902         var l int
1903         _ = l
1904         l = len(m.ID)
1905         n += 1 + l + sovGenerated(uint64(l))
1906         l = len(m.Schema)
1907         n += 1 + l + sovGenerated(uint64(l))
1908         if m.Ref != nil {
1909                 l = len(*m.Ref)
1910                 n += 1 + l + sovGenerated(uint64(l))
1911         }
1912         l = len(m.Description)
1913         n += 1 + l + sovGenerated(uint64(l))
1914         l = len(m.Type)
1915         n += 1 + l + sovGenerated(uint64(l))
1916         l = len(m.Format)
1917         n += 1 + l + sovGenerated(uint64(l))
1918         l = len(m.Title)
1919         n += 1 + l + sovGenerated(uint64(l))
1920         if m.Default != nil {
1921                 l = m.Default.Size()
1922                 n += 1 + l + sovGenerated(uint64(l))
1923         }
1924         if m.Maximum != nil {
1925                 n += 9
1926         }
1927         n += 2
1928         if m.Minimum != nil {
1929                 n += 9
1930         }
1931         n += 2
1932         if m.MaxLength != nil {
1933                 n += 1 + sovGenerated(uint64(*m.MaxLength))
1934         }
1935         if m.MinLength != nil {
1936                 n += 1 + sovGenerated(uint64(*m.MinLength))
1937         }
1938         l = len(m.Pattern)
1939         n += 1 + l + sovGenerated(uint64(l))
1940         if m.MaxItems != nil {
1941                 n += 2 + sovGenerated(uint64(*m.MaxItems))
1942         }
1943         if m.MinItems != nil {
1944                 n += 2 + sovGenerated(uint64(*m.MinItems))
1945         }
1946         n += 3
1947         if m.MultipleOf != nil {
1948                 n += 10
1949         }
1950         if len(m.Enum) > 0 {
1951                 for _, e := range m.Enum {
1952                         l = e.Size()
1953                         n += 2 + l + sovGenerated(uint64(l))
1954                 }
1955         }
1956         if m.MaxProperties != nil {
1957                 n += 2 + sovGenerated(uint64(*m.MaxProperties))
1958         }
1959         if m.MinProperties != nil {
1960                 n += 2 + sovGenerated(uint64(*m.MinProperties))
1961         }
1962         if len(m.Required) > 0 {
1963                 for _, s := range m.Required {
1964                         l = len(s)
1965                         n += 2 + l + sovGenerated(uint64(l))
1966                 }
1967         }
1968         if m.Items != nil {
1969                 l = m.Items.Size()
1970                 n += 2 + l + sovGenerated(uint64(l))
1971         }
1972         if len(m.AllOf) > 0 {
1973                 for _, e := range m.AllOf {
1974                         l = e.Size()
1975                         n += 2 + l + sovGenerated(uint64(l))
1976                 }
1977         }
1978         if len(m.OneOf) > 0 {
1979                 for _, e := range m.OneOf {
1980                         l = e.Size()
1981                         n += 2 + l + sovGenerated(uint64(l))
1982                 }
1983         }
1984         if len(m.AnyOf) > 0 {
1985                 for _, e := range m.AnyOf {
1986                         l = e.Size()
1987                         n += 2 + l + sovGenerated(uint64(l))
1988                 }
1989         }
1990         if m.Not != nil {
1991                 l = m.Not.Size()
1992                 n += 2 + l + sovGenerated(uint64(l))
1993         }
1994         if len(m.Properties) > 0 {
1995                 for k, v := range m.Properties {
1996                         _ = k
1997                         _ = v
1998                         l = v.Size()
1999                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
2000                         n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
2001                 }
2002         }
2003         if m.AdditionalProperties != nil {
2004                 l = m.AdditionalProperties.Size()
2005                 n += 2 + l + sovGenerated(uint64(l))
2006         }
2007         if len(m.PatternProperties) > 0 {
2008                 for k, v := range m.PatternProperties {
2009                         _ = k
2010                         _ = v
2011                         l = v.Size()
2012                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
2013                         n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
2014                 }
2015         }
2016         if len(m.Dependencies) > 0 {
2017                 for k, v := range m.Dependencies {
2018                         _ = k
2019                         _ = v
2020                         l = v.Size()
2021                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
2022                         n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
2023                 }
2024         }
2025         if m.AdditionalItems != nil {
2026                 l = m.AdditionalItems.Size()
2027                 n += 2 + l + sovGenerated(uint64(l))
2028         }
2029         if len(m.Definitions) > 0 {
2030                 for k, v := range m.Definitions {
2031                         _ = k
2032                         _ = v
2033                         l = v.Size()
2034                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
2035                         n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
2036                 }
2037         }
2038         if m.ExternalDocs != nil {
2039                 l = m.ExternalDocs.Size()
2040                 n += 2 + l + sovGenerated(uint64(l))
2041         }
2042         if m.Example != nil {
2043                 l = m.Example.Size()
2044                 n += 2 + l + sovGenerated(uint64(l))
2045         }
2046         return n
2047 }
2048
2049 func (m *JSONSchemaPropsOrArray) Size() (n int) {
2050         var l int
2051         _ = l
2052         if m.Schema != nil {
2053                 l = m.Schema.Size()
2054                 n += 1 + l + sovGenerated(uint64(l))
2055         }
2056         if len(m.JSONSchemas) > 0 {
2057                 for _, e := range m.JSONSchemas {
2058                         l = e.Size()
2059                         n += 1 + l + sovGenerated(uint64(l))
2060                 }
2061         }
2062         return n
2063 }
2064
2065 func (m *JSONSchemaPropsOrBool) Size() (n int) {
2066         var l int
2067         _ = l
2068         n += 2
2069         if m.Schema != nil {
2070                 l = m.Schema.Size()
2071                 n += 1 + l + sovGenerated(uint64(l))
2072         }
2073         return n
2074 }
2075
2076 func (m *JSONSchemaPropsOrStringArray) Size() (n int) {
2077         var l int
2078         _ = l
2079         if m.Schema != nil {
2080                 l = m.Schema.Size()
2081                 n += 1 + l + sovGenerated(uint64(l))
2082         }
2083         if len(m.Property) > 0 {
2084                 for _, s := range m.Property {
2085                         l = len(s)
2086                         n += 1 + l + sovGenerated(uint64(l))
2087                 }
2088         }
2089         return n
2090 }
2091
2092 func (m *ServiceReference) Size() (n int) {
2093         var l int
2094         _ = l
2095         l = len(m.Namespace)
2096         n += 1 + l + sovGenerated(uint64(l))
2097         l = len(m.Name)
2098         n += 1 + l + sovGenerated(uint64(l))
2099         if m.Path != nil {
2100                 l = len(*m.Path)
2101                 n += 1 + l + sovGenerated(uint64(l))
2102         }
2103         return n
2104 }
2105
2106 func (m *WebhookClientConfig) Size() (n int) {
2107         var l int
2108         _ = l
2109         if m.Service != nil {
2110                 l = m.Service.Size()
2111                 n += 1 + l + sovGenerated(uint64(l))
2112         }
2113         if m.CABundle != nil {
2114                 l = len(m.CABundle)
2115                 n += 1 + l + sovGenerated(uint64(l))
2116         }
2117         if m.URL != nil {
2118                 l = len(*m.URL)
2119                 n += 1 + l + sovGenerated(uint64(l))
2120         }
2121         return n
2122 }
2123
2124 func sovGenerated(x uint64) (n int) {
2125         for {
2126                 n++
2127                 x >>= 7
2128                 if x == 0 {
2129                         break
2130                 }
2131         }
2132         return n
2133 }
2134 func sozGenerated(x uint64) (n int) {
2135         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2136 }
2137 func (this *ConversionRequest) String() string {
2138         if this == nil {
2139                 return "nil"
2140         }
2141         s := strings.Join([]string{`&ConversionRequest{`,
2142                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2143                 `DesiredAPIVersion:` + fmt.Sprintf("%v", this.DesiredAPIVersion) + `,`,
2144                 `Objects:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Objects), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2145                 `}`,
2146         }, "")
2147         return s
2148 }
2149 func (this *ConversionResponse) String() string {
2150         if this == nil {
2151                 return "nil"
2152         }
2153         s := strings.Join([]string{`&ConversionResponse{`,
2154                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2155                 `ConvertedObjects:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ConvertedObjects), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2156                 `Result:` + strings.Replace(strings.Replace(this.Result.String(), "Status", "k8s_io_apimachinery_pkg_apis_meta_v1.Status", 1), `&`, ``, 1) + `,`,
2157                 `}`,
2158         }, "")
2159         return s
2160 }
2161 func (this *ConversionReview) String() string {
2162         if this == nil {
2163                 return "nil"
2164         }
2165         s := strings.Join([]string{`&ConversionReview{`,
2166                 `Request:` + strings.Replace(fmt.Sprintf("%v", this.Request), "ConversionRequest", "ConversionRequest", 1) + `,`,
2167                 `Response:` + strings.Replace(fmt.Sprintf("%v", this.Response), "ConversionResponse", "ConversionResponse", 1) + `,`,
2168                 `}`,
2169         }, "")
2170         return s
2171 }
2172 func (this *CustomResourceColumnDefinition) String() string {
2173         if this == nil {
2174                 return "nil"
2175         }
2176         s := strings.Join([]string{`&CustomResourceColumnDefinition{`,
2177                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2178                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2179                 `Format:` + fmt.Sprintf("%v", this.Format) + `,`,
2180                 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
2181                 `Priority:` + fmt.Sprintf("%v", this.Priority) + `,`,
2182                 `JSONPath:` + fmt.Sprintf("%v", this.JSONPath) + `,`,
2183                 `}`,
2184         }, "")
2185         return s
2186 }
2187 func (this *CustomResourceConversion) String() string {
2188         if this == nil {
2189                 return "nil"
2190         }
2191         s := strings.Join([]string{`&CustomResourceConversion{`,
2192                 `Strategy:` + fmt.Sprintf("%v", this.Strategy) + `,`,
2193                 `WebhookClientConfig:` + strings.Replace(fmt.Sprintf("%v", this.WebhookClientConfig), "WebhookClientConfig", "WebhookClientConfig", 1) + `,`,
2194                 `}`,
2195         }, "")
2196         return s
2197 }
2198 func (this *CustomResourceDefinition) String() string {
2199         if this == nil {
2200                 return "nil"
2201         }
2202         s := strings.Join([]string{`&CustomResourceDefinition{`,
2203                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2204                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CustomResourceDefinitionSpec", "CustomResourceDefinitionSpec", 1), `&`, ``, 1) + `,`,
2205                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CustomResourceDefinitionStatus", "CustomResourceDefinitionStatus", 1), `&`, ``, 1) + `,`,
2206                 `}`,
2207         }, "")
2208         return s
2209 }
2210 func (this *CustomResourceDefinitionCondition) String() string {
2211         if this == nil {
2212                 return "nil"
2213         }
2214         s := strings.Join([]string{`&CustomResourceDefinitionCondition{`,
2215                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2216                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2217                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
2218                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2219                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2220                 `}`,
2221         }, "")
2222         return s
2223 }
2224 func (this *CustomResourceDefinitionList) String() string {
2225         if this == nil {
2226                 return "nil"
2227         }
2228         s := strings.Join([]string{`&CustomResourceDefinitionList{`,
2229                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
2230                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "CustomResourceDefinition", "CustomResourceDefinition", 1), `&`, ``, 1) + `,`,
2231                 `}`,
2232         }, "")
2233         return s
2234 }
2235 func (this *CustomResourceDefinitionNames) String() string {
2236         if this == nil {
2237                 return "nil"
2238         }
2239         s := strings.Join([]string{`&CustomResourceDefinitionNames{`,
2240                 `Plural:` + fmt.Sprintf("%v", this.Plural) + `,`,
2241                 `Singular:` + fmt.Sprintf("%v", this.Singular) + `,`,
2242                 `ShortNames:` + fmt.Sprintf("%v", this.ShortNames) + `,`,
2243                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2244                 `ListKind:` + fmt.Sprintf("%v", this.ListKind) + `,`,
2245                 `Categories:` + fmt.Sprintf("%v", this.Categories) + `,`,
2246                 `}`,
2247         }, "")
2248         return s
2249 }
2250 func (this *CustomResourceDefinitionSpec) String() string {
2251         if this == nil {
2252                 return "nil"
2253         }
2254         s := strings.Join([]string{`&CustomResourceDefinitionSpec{`,
2255                 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
2256                 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
2257                 `Names:` + strings.Replace(strings.Replace(this.Names.String(), "CustomResourceDefinitionNames", "CustomResourceDefinitionNames", 1), `&`, ``, 1) + `,`,
2258                 `Scope:` + fmt.Sprintf("%v", this.Scope) + `,`,
2259                 `Validation:` + strings.Replace(fmt.Sprintf("%v", this.Validation), "CustomResourceValidation", "CustomResourceValidation", 1) + `,`,
2260                 `Subresources:` + strings.Replace(fmt.Sprintf("%v", this.Subresources), "CustomResourceSubresources", "CustomResourceSubresources", 1) + `,`,
2261                 `Versions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Versions), "CustomResourceDefinitionVersion", "CustomResourceDefinitionVersion", 1), `&`, ``, 1) + `,`,
2262                 `AdditionalPrinterColumns:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AdditionalPrinterColumns), "CustomResourceColumnDefinition", "CustomResourceColumnDefinition", 1), `&`, ``, 1) + `,`,
2263                 `Conversion:` + strings.Replace(fmt.Sprintf("%v", this.Conversion), "CustomResourceConversion", "CustomResourceConversion", 1) + `,`,
2264                 `}`,
2265         }, "")
2266         return s
2267 }
2268 func (this *CustomResourceDefinitionStatus) String() string {
2269         if this == nil {
2270                 return "nil"
2271         }
2272         s := strings.Join([]string{`&CustomResourceDefinitionStatus{`,
2273                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "CustomResourceDefinitionCondition", "CustomResourceDefinitionCondition", 1), `&`, ``, 1) + `,`,
2274                 `AcceptedNames:` + strings.Replace(strings.Replace(this.AcceptedNames.String(), "CustomResourceDefinitionNames", "CustomResourceDefinitionNames", 1), `&`, ``, 1) + `,`,
2275                 `StoredVersions:` + fmt.Sprintf("%v", this.StoredVersions) + `,`,
2276                 `}`,
2277         }, "")
2278         return s
2279 }
2280 func (this *CustomResourceDefinitionVersion) String() string {
2281         if this == nil {
2282                 return "nil"
2283         }
2284         s := strings.Join([]string{`&CustomResourceDefinitionVersion{`,
2285                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2286                 `Served:` + fmt.Sprintf("%v", this.Served) + `,`,
2287                 `Storage:` + fmt.Sprintf("%v", this.Storage) + `,`,
2288                 `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "CustomResourceValidation", "CustomResourceValidation", 1) + `,`,
2289                 `Subresources:` + strings.Replace(fmt.Sprintf("%v", this.Subresources), "CustomResourceSubresources", "CustomResourceSubresources", 1) + `,`,
2290                 `AdditionalPrinterColumns:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AdditionalPrinterColumns), "CustomResourceColumnDefinition", "CustomResourceColumnDefinition", 1), `&`, ``, 1) + `,`,
2291                 `}`,
2292         }, "")
2293         return s
2294 }
2295 func (this *CustomResourceSubresourceScale) String() string {
2296         if this == nil {
2297                 return "nil"
2298         }
2299         s := strings.Join([]string{`&CustomResourceSubresourceScale{`,
2300                 `SpecReplicasPath:` + fmt.Sprintf("%v", this.SpecReplicasPath) + `,`,
2301                 `StatusReplicasPath:` + fmt.Sprintf("%v", this.StatusReplicasPath) + `,`,
2302                 `LabelSelectorPath:` + valueToStringGenerated(this.LabelSelectorPath) + `,`,
2303                 `}`,
2304         }, "")
2305         return s
2306 }
2307 func (this *CustomResourceSubresourceStatus) String() string {
2308         if this == nil {
2309                 return "nil"
2310         }
2311         s := strings.Join([]string{`&CustomResourceSubresourceStatus{`,
2312                 `}`,
2313         }, "")
2314         return s
2315 }
2316 func (this *CustomResourceSubresources) String() string {
2317         if this == nil {
2318                 return "nil"
2319         }
2320         s := strings.Join([]string{`&CustomResourceSubresources{`,
2321                 `Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "CustomResourceSubresourceStatus", "CustomResourceSubresourceStatus", 1) + `,`,
2322                 `Scale:` + strings.Replace(fmt.Sprintf("%v", this.Scale), "CustomResourceSubresourceScale", "CustomResourceSubresourceScale", 1) + `,`,
2323                 `}`,
2324         }, "")
2325         return s
2326 }
2327 func (this *CustomResourceValidation) String() string {
2328         if this == nil {
2329                 return "nil"
2330         }
2331         s := strings.Join([]string{`&CustomResourceValidation{`,
2332                 `OpenAPIV3Schema:` + strings.Replace(fmt.Sprintf("%v", this.OpenAPIV3Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
2333                 `}`,
2334         }, "")
2335         return s
2336 }
2337 func (this *ExternalDocumentation) String() string {
2338         if this == nil {
2339                 return "nil"
2340         }
2341         s := strings.Join([]string{`&ExternalDocumentation{`,
2342                 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
2343                 `URL:` + fmt.Sprintf("%v", this.URL) + `,`,
2344                 `}`,
2345         }, "")
2346         return s
2347 }
2348 func (this *JSON) String() string {
2349         if this == nil {
2350                 return "nil"
2351         }
2352         s := strings.Join([]string{`&JSON{`,
2353                 `Raw:` + valueToStringGenerated(this.Raw) + `,`,
2354                 `}`,
2355         }, "")
2356         return s
2357 }
2358 func (this *JSONSchemaProps) String() string {
2359         if this == nil {
2360                 return "nil"
2361         }
2362         keysForProperties := make([]string, 0, len(this.Properties))
2363         for k := range this.Properties {
2364                 keysForProperties = append(keysForProperties, k)
2365         }
2366         github_com_gogo_protobuf_sortkeys.Strings(keysForProperties)
2367         mapStringForProperties := "map[string]JSONSchemaProps{"
2368         for _, k := range keysForProperties {
2369                 mapStringForProperties += fmt.Sprintf("%v: %v,", k, this.Properties[k])
2370         }
2371         mapStringForProperties += "}"
2372         keysForPatternProperties := make([]string, 0, len(this.PatternProperties))
2373         for k := range this.PatternProperties {
2374                 keysForPatternProperties = append(keysForPatternProperties, k)
2375         }
2376         github_com_gogo_protobuf_sortkeys.Strings(keysForPatternProperties)
2377         mapStringForPatternProperties := "map[string]JSONSchemaProps{"
2378         for _, k := range keysForPatternProperties {
2379                 mapStringForPatternProperties += fmt.Sprintf("%v: %v,", k, this.PatternProperties[k])
2380         }
2381         mapStringForPatternProperties += "}"
2382         keysForDependencies := make([]string, 0, len(this.Dependencies))
2383         for k := range this.Dependencies {
2384                 keysForDependencies = append(keysForDependencies, k)
2385         }
2386         github_com_gogo_protobuf_sortkeys.Strings(keysForDependencies)
2387         mapStringForDependencies := "JSONSchemaDependencies{"
2388         for _, k := range keysForDependencies {
2389                 mapStringForDependencies += fmt.Sprintf("%v: %v,", k, this.Dependencies[k])
2390         }
2391         mapStringForDependencies += "}"
2392         keysForDefinitions := make([]string, 0, len(this.Definitions))
2393         for k := range this.Definitions {
2394                 keysForDefinitions = append(keysForDefinitions, k)
2395         }
2396         github_com_gogo_protobuf_sortkeys.Strings(keysForDefinitions)
2397         mapStringForDefinitions := "JSONSchemaDefinitions{"
2398         for _, k := range keysForDefinitions {
2399                 mapStringForDefinitions += fmt.Sprintf("%v: %v,", k, this.Definitions[k])
2400         }
2401         mapStringForDefinitions += "}"
2402         s := strings.Join([]string{`&JSONSchemaProps{`,
2403                 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2404                 `Schema:` + fmt.Sprintf("%v", this.Schema) + `,`,
2405                 `Ref:` + valueToStringGenerated(this.Ref) + `,`,
2406                 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
2407                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2408                 `Format:` + fmt.Sprintf("%v", this.Format) + `,`,
2409                 `Title:` + fmt.Sprintf("%v", this.Title) + `,`,
2410                 `Default:` + strings.Replace(fmt.Sprintf("%v", this.Default), "JSON", "JSON", 1) + `,`,
2411                 `Maximum:` + valueToStringGenerated(this.Maximum) + `,`,
2412                 `ExclusiveMaximum:` + fmt.Sprintf("%v", this.ExclusiveMaximum) + `,`,
2413                 `Minimum:` + valueToStringGenerated(this.Minimum) + `,`,
2414                 `ExclusiveMinimum:` + fmt.Sprintf("%v", this.ExclusiveMinimum) + `,`,
2415                 `MaxLength:` + valueToStringGenerated(this.MaxLength) + `,`,
2416                 `MinLength:` + valueToStringGenerated(this.MinLength) + `,`,
2417                 `Pattern:` + fmt.Sprintf("%v", this.Pattern) + `,`,
2418                 `MaxItems:` + valueToStringGenerated(this.MaxItems) + `,`,
2419                 `MinItems:` + valueToStringGenerated(this.MinItems) + `,`,
2420                 `UniqueItems:` + fmt.Sprintf("%v", this.UniqueItems) + `,`,
2421                 `MultipleOf:` + valueToStringGenerated(this.MultipleOf) + `,`,
2422                 `Enum:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Enum), "JSON", "JSON", 1), `&`, ``, 1) + `,`,
2423                 `MaxProperties:` + valueToStringGenerated(this.MaxProperties) + `,`,
2424                 `MinProperties:` + valueToStringGenerated(this.MinProperties) + `,`,
2425                 `Required:` + fmt.Sprintf("%v", this.Required) + `,`,
2426                 `Items:` + strings.Replace(fmt.Sprintf("%v", this.Items), "JSONSchemaPropsOrArray", "JSONSchemaPropsOrArray", 1) + `,`,
2427                 `AllOf:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllOf), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`,
2428                 `OneOf:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OneOf), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`,
2429                 `AnyOf:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AnyOf), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`,
2430                 `Not:` + strings.Replace(fmt.Sprintf("%v", this.Not), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
2431                 `Properties:` + mapStringForProperties + `,`,
2432                 `AdditionalProperties:` + strings.Replace(fmt.Sprintf("%v", this.AdditionalProperties), "JSONSchemaPropsOrBool", "JSONSchemaPropsOrBool", 1) + `,`,
2433                 `PatternProperties:` + mapStringForPatternProperties + `,`,
2434                 `Dependencies:` + mapStringForDependencies + `,`,
2435                 `AdditionalItems:` + strings.Replace(fmt.Sprintf("%v", this.AdditionalItems), "JSONSchemaPropsOrBool", "JSONSchemaPropsOrBool", 1) + `,`,
2436                 `Definitions:` + mapStringForDefinitions + `,`,
2437                 `ExternalDocs:` + strings.Replace(fmt.Sprintf("%v", this.ExternalDocs), "ExternalDocumentation", "ExternalDocumentation", 1) + `,`,
2438                 `Example:` + strings.Replace(fmt.Sprintf("%v", this.Example), "JSON", "JSON", 1) + `,`,
2439                 `}`,
2440         }, "")
2441         return s
2442 }
2443 func (this *JSONSchemaPropsOrArray) String() string {
2444         if this == nil {
2445                 return "nil"
2446         }
2447         s := strings.Join([]string{`&JSONSchemaPropsOrArray{`,
2448                 `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
2449                 `JSONSchemas:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.JSONSchemas), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`,
2450                 `}`,
2451         }, "")
2452         return s
2453 }
2454 func (this *JSONSchemaPropsOrBool) String() string {
2455         if this == nil {
2456                 return "nil"
2457         }
2458         s := strings.Join([]string{`&JSONSchemaPropsOrBool{`,
2459                 `Allows:` + fmt.Sprintf("%v", this.Allows) + `,`,
2460                 `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
2461                 `}`,
2462         }, "")
2463         return s
2464 }
2465 func (this *JSONSchemaPropsOrStringArray) String() string {
2466         if this == nil {
2467                 return "nil"
2468         }
2469         s := strings.Join([]string{`&JSONSchemaPropsOrStringArray{`,
2470                 `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
2471                 `Property:` + fmt.Sprintf("%v", this.Property) + `,`,
2472                 `}`,
2473         }, "")
2474         return s
2475 }
2476 func (this *ServiceReference) String() string {
2477         if this == nil {
2478                 return "nil"
2479         }
2480         s := strings.Join([]string{`&ServiceReference{`,
2481                 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
2482                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2483                 `Path:` + valueToStringGenerated(this.Path) + `,`,
2484                 `}`,
2485         }, "")
2486         return s
2487 }
2488 func (this *WebhookClientConfig) String() string {
2489         if this == nil {
2490                 return "nil"
2491         }
2492         s := strings.Join([]string{`&WebhookClientConfig{`,
2493                 `Service:` + strings.Replace(fmt.Sprintf("%v", this.Service), "ServiceReference", "ServiceReference", 1) + `,`,
2494                 `CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
2495                 `URL:` + valueToStringGenerated(this.URL) + `,`,
2496                 `}`,
2497         }, "")
2498         return s
2499 }
2500 func valueToStringGenerated(v interface{}) string {
2501         rv := reflect.ValueOf(v)
2502         if rv.IsNil() {
2503                 return "nil"
2504         }
2505         pv := reflect.Indirect(rv).Interface()
2506         return fmt.Sprintf("*%v", pv)
2507 }
2508 func (m *ConversionRequest) Unmarshal(dAtA []byte) error {
2509         l := len(dAtA)
2510         iNdEx := 0
2511         for iNdEx < l {
2512                 preIndex := iNdEx
2513                 var wire uint64
2514                 for shift := uint(0); ; shift += 7 {
2515                         if shift >= 64 {
2516                                 return ErrIntOverflowGenerated
2517                         }
2518                         if iNdEx >= l {
2519                                 return io.ErrUnexpectedEOF
2520                         }
2521                         b := dAtA[iNdEx]
2522                         iNdEx++
2523                         wire |= (uint64(b) & 0x7F) << shift
2524                         if b < 0x80 {
2525                                 break
2526                         }
2527                 }
2528                 fieldNum := int32(wire >> 3)
2529                 wireType := int(wire & 0x7)
2530                 if wireType == 4 {
2531                         return fmt.Errorf("proto: ConversionRequest: wiretype end group for non-group")
2532                 }
2533                 if fieldNum <= 0 {
2534                         return fmt.Errorf("proto: ConversionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
2535                 }
2536                 switch fieldNum {
2537                 case 1:
2538                         if wireType != 2 {
2539                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
2540                         }
2541                         var stringLen uint64
2542                         for shift := uint(0); ; shift += 7 {
2543                                 if shift >= 64 {
2544                                         return ErrIntOverflowGenerated
2545                                 }
2546                                 if iNdEx >= l {
2547                                         return io.ErrUnexpectedEOF
2548                                 }
2549                                 b := dAtA[iNdEx]
2550                                 iNdEx++
2551                                 stringLen |= (uint64(b) & 0x7F) << shift
2552                                 if b < 0x80 {
2553                                         break
2554                                 }
2555                         }
2556                         intStringLen := int(stringLen)
2557                         if intStringLen < 0 {
2558                                 return ErrInvalidLengthGenerated
2559                         }
2560                         postIndex := iNdEx + intStringLen
2561                         if postIndex > l {
2562                                 return io.ErrUnexpectedEOF
2563                         }
2564                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
2565                         iNdEx = postIndex
2566                 case 2:
2567                         if wireType != 2 {
2568                                 return fmt.Errorf("proto: wrong wireType = %d for field DesiredAPIVersion", wireType)
2569                         }
2570                         var stringLen uint64
2571                         for shift := uint(0); ; shift += 7 {
2572                                 if shift >= 64 {
2573                                         return ErrIntOverflowGenerated
2574                                 }
2575                                 if iNdEx >= l {
2576                                         return io.ErrUnexpectedEOF
2577                                 }
2578                                 b := dAtA[iNdEx]
2579                                 iNdEx++
2580                                 stringLen |= (uint64(b) & 0x7F) << shift
2581                                 if b < 0x80 {
2582                                         break
2583                                 }
2584                         }
2585                         intStringLen := int(stringLen)
2586                         if intStringLen < 0 {
2587                                 return ErrInvalidLengthGenerated
2588                         }
2589                         postIndex := iNdEx + intStringLen
2590                         if postIndex > l {
2591                                 return io.ErrUnexpectedEOF
2592                         }
2593                         m.DesiredAPIVersion = string(dAtA[iNdEx:postIndex])
2594                         iNdEx = postIndex
2595                 case 3:
2596                         if wireType != 2 {
2597                                 return fmt.Errorf("proto: wrong wireType = %d for field Objects", wireType)
2598                         }
2599                         var msglen int
2600                         for shift := uint(0); ; shift += 7 {
2601                                 if shift >= 64 {
2602                                         return ErrIntOverflowGenerated
2603                                 }
2604                                 if iNdEx >= l {
2605                                         return io.ErrUnexpectedEOF
2606                                 }
2607                                 b := dAtA[iNdEx]
2608                                 iNdEx++
2609                                 msglen |= (int(b) & 0x7F) << shift
2610                                 if b < 0x80 {
2611                                         break
2612                                 }
2613                         }
2614                         if msglen < 0 {
2615                                 return ErrInvalidLengthGenerated
2616                         }
2617                         postIndex := iNdEx + msglen
2618                         if postIndex > l {
2619                                 return io.ErrUnexpectedEOF
2620                         }
2621                         m.Objects = append(m.Objects, k8s_io_apimachinery_pkg_runtime.RawExtension{})
2622                         if err := m.Objects[len(m.Objects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2623                                 return err
2624                         }
2625                         iNdEx = postIndex
2626                 default:
2627                         iNdEx = preIndex
2628                         skippy, err := skipGenerated(dAtA[iNdEx:])
2629                         if err != nil {
2630                                 return err
2631                         }
2632                         if skippy < 0 {
2633                                 return ErrInvalidLengthGenerated
2634                         }
2635                         if (iNdEx + skippy) > l {
2636                                 return io.ErrUnexpectedEOF
2637                         }
2638                         iNdEx += skippy
2639                 }
2640         }
2641
2642         if iNdEx > l {
2643                 return io.ErrUnexpectedEOF
2644         }
2645         return nil
2646 }
2647 func (m *ConversionResponse) Unmarshal(dAtA []byte) error {
2648         l := len(dAtA)
2649         iNdEx := 0
2650         for iNdEx < l {
2651                 preIndex := iNdEx
2652                 var wire uint64
2653                 for shift := uint(0); ; shift += 7 {
2654                         if shift >= 64 {
2655                                 return ErrIntOverflowGenerated
2656                         }
2657                         if iNdEx >= l {
2658                                 return io.ErrUnexpectedEOF
2659                         }
2660                         b := dAtA[iNdEx]
2661                         iNdEx++
2662                         wire |= (uint64(b) & 0x7F) << shift
2663                         if b < 0x80 {
2664                                 break
2665                         }
2666                 }
2667                 fieldNum := int32(wire >> 3)
2668                 wireType := int(wire & 0x7)
2669                 if wireType == 4 {
2670                         return fmt.Errorf("proto: ConversionResponse: wiretype end group for non-group")
2671                 }
2672                 if fieldNum <= 0 {
2673                         return fmt.Errorf("proto: ConversionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
2674                 }
2675                 switch fieldNum {
2676                 case 1:
2677                         if wireType != 2 {
2678                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
2679                         }
2680                         var stringLen uint64
2681                         for shift := uint(0); ; shift += 7 {
2682                                 if shift >= 64 {
2683                                         return ErrIntOverflowGenerated
2684                                 }
2685                                 if iNdEx >= l {
2686                                         return io.ErrUnexpectedEOF
2687                                 }
2688                                 b := dAtA[iNdEx]
2689                                 iNdEx++
2690                                 stringLen |= (uint64(b) & 0x7F) << shift
2691                                 if b < 0x80 {
2692                                         break
2693                                 }
2694                         }
2695                         intStringLen := int(stringLen)
2696                         if intStringLen < 0 {
2697                                 return ErrInvalidLengthGenerated
2698                         }
2699                         postIndex := iNdEx + intStringLen
2700                         if postIndex > l {
2701                                 return io.ErrUnexpectedEOF
2702                         }
2703                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
2704                         iNdEx = postIndex
2705                 case 2:
2706                         if wireType != 2 {
2707                                 return fmt.Errorf("proto: wrong wireType = %d for field ConvertedObjects", wireType)
2708                         }
2709                         var msglen int
2710                         for shift := uint(0); ; shift += 7 {
2711                                 if shift >= 64 {
2712                                         return ErrIntOverflowGenerated
2713                                 }
2714                                 if iNdEx >= l {
2715                                         return io.ErrUnexpectedEOF
2716                                 }
2717                                 b := dAtA[iNdEx]
2718                                 iNdEx++
2719                                 msglen |= (int(b) & 0x7F) << shift
2720                                 if b < 0x80 {
2721                                         break
2722                                 }
2723                         }
2724                         if msglen < 0 {
2725                                 return ErrInvalidLengthGenerated
2726                         }
2727                         postIndex := iNdEx + msglen
2728                         if postIndex > l {
2729                                 return io.ErrUnexpectedEOF
2730                         }
2731                         m.ConvertedObjects = append(m.ConvertedObjects, k8s_io_apimachinery_pkg_runtime.RawExtension{})
2732                         if err := m.ConvertedObjects[len(m.ConvertedObjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2733                                 return err
2734                         }
2735                         iNdEx = postIndex
2736                 case 3:
2737                         if wireType != 2 {
2738                                 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
2739                         }
2740                         var msglen int
2741                         for shift := uint(0); ; shift += 7 {
2742                                 if shift >= 64 {
2743                                         return ErrIntOverflowGenerated
2744                                 }
2745                                 if iNdEx >= l {
2746                                         return io.ErrUnexpectedEOF
2747                                 }
2748                                 b := dAtA[iNdEx]
2749                                 iNdEx++
2750                                 msglen |= (int(b) & 0x7F) << shift
2751                                 if b < 0x80 {
2752                                         break
2753                                 }
2754                         }
2755                         if msglen < 0 {
2756                                 return ErrInvalidLengthGenerated
2757                         }
2758                         postIndex := iNdEx + msglen
2759                         if postIndex > l {
2760                                 return io.ErrUnexpectedEOF
2761                         }
2762                         if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2763                                 return err
2764                         }
2765                         iNdEx = postIndex
2766                 default:
2767                         iNdEx = preIndex
2768                         skippy, err := skipGenerated(dAtA[iNdEx:])
2769                         if err != nil {
2770                                 return err
2771                         }
2772                         if skippy < 0 {
2773                                 return ErrInvalidLengthGenerated
2774                         }
2775                         if (iNdEx + skippy) > l {
2776                                 return io.ErrUnexpectedEOF
2777                         }
2778                         iNdEx += skippy
2779                 }
2780         }
2781
2782         if iNdEx > l {
2783                 return io.ErrUnexpectedEOF
2784         }
2785         return nil
2786 }
2787 func (m *ConversionReview) Unmarshal(dAtA []byte) error {
2788         l := len(dAtA)
2789         iNdEx := 0
2790         for iNdEx < l {
2791                 preIndex := iNdEx
2792                 var wire uint64
2793                 for shift := uint(0); ; shift += 7 {
2794                         if shift >= 64 {
2795                                 return ErrIntOverflowGenerated
2796                         }
2797                         if iNdEx >= l {
2798                                 return io.ErrUnexpectedEOF
2799                         }
2800                         b := dAtA[iNdEx]
2801                         iNdEx++
2802                         wire |= (uint64(b) & 0x7F) << shift
2803                         if b < 0x80 {
2804                                 break
2805                         }
2806                 }
2807                 fieldNum := int32(wire >> 3)
2808                 wireType := int(wire & 0x7)
2809                 if wireType == 4 {
2810                         return fmt.Errorf("proto: ConversionReview: wiretype end group for non-group")
2811                 }
2812                 if fieldNum <= 0 {
2813                         return fmt.Errorf("proto: ConversionReview: illegal tag %d (wire type %d)", fieldNum, wire)
2814                 }
2815                 switch fieldNum {
2816                 case 1:
2817                         if wireType != 2 {
2818                                 return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
2819                         }
2820                         var msglen int
2821                         for shift := uint(0); ; shift += 7 {
2822                                 if shift >= 64 {
2823                                         return ErrIntOverflowGenerated
2824                                 }
2825                                 if iNdEx >= l {
2826                                         return io.ErrUnexpectedEOF
2827                                 }
2828                                 b := dAtA[iNdEx]
2829                                 iNdEx++
2830                                 msglen |= (int(b) & 0x7F) << shift
2831                                 if b < 0x80 {
2832                                         break
2833                                 }
2834                         }
2835                         if msglen < 0 {
2836                                 return ErrInvalidLengthGenerated
2837                         }
2838                         postIndex := iNdEx + msglen
2839                         if postIndex > l {
2840                                 return io.ErrUnexpectedEOF
2841                         }
2842                         if m.Request == nil {
2843                                 m.Request = &ConversionRequest{}
2844                         }
2845                         if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2846                                 return err
2847                         }
2848                         iNdEx = postIndex
2849                 case 2:
2850                         if wireType != 2 {
2851                                 return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
2852                         }
2853                         var msglen int
2854                         for shift := uint(0); ; shift += 7 {
2855                                 if shift >= 64 {
2856                                         return ErrIntOverflowGenerated
2857                                 }
2858                                 if iNdEx >= l {
2859                                         return io.ErrUnexpectedEOF
2860                                 }
2861                                 b := dAtA[iNdEx]
2862                                 iNdEx++
2863                                 msglen |= (int(b) & 0x7F) << shift
2864                                 if b < 0x80 {
2865                                         break
2866                                 }
2867                         }
2868                         if msglen < 0 {
2869                                 return ErrInvalidLengthGenerated
2870                         }
2871                         postIndex := iNdEx + msglen
2872                         if postIndex > l {
2873                                 return io.ErrUnexpectedEOF
2874                         }
2875                         if m.Response == nil {
2876                                 m.Response = &ConversionResponse{}
2877                         }
2878                         if err := m.Response.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2879                                 return err
2880                         }
2881                         iNdEx = postIndex
2882                 default:
2883                         iNdEx = preIndex
2884                         skippy, err := skipGenerated(dAtA[iNdEx:])
2885                         if err != nil {
2886                                 return err
2887                         }
2888                         if skippy < 0 {
2889                                 return ErrInvalidLengthGenerated
2890                         }
2891                         if (iNdEx + skippy) > l {
2892                                 return io.ErrUnexpectedEOF
2893                         }
2894                         iNdEx += skippy
2895                 }
2896         }
2897
2898         if iNdEx > l {
2899                 return io.ErrUnexpectedEOF
2900         }
2901         return nil
2902 }
2903 func (m *CustomResourceColumnDefinition) Unmarshal(dAtA []byte) error {
2904         l := len(dAtA)
2905         iNdEx := 0
2906         for iNdEx < l {
2907                 preIndex := iNdEx
2908                 var wire uint64
2909                 for shift := uint(0); ; shift += 7 {
2910                         if shift >= 64 {
2911                                 return ErrIntOverflowGenerated
2912                         }
2913                         if iNdEx >= l {
2914                                 return io.ErrUnexpectedEOF
2915                         }
2916                         b := dAtA[iNdEx]
2917                         iNdEx++
2918                         wire |= (uint64(b) & 0x7F) << shift
2919                         if b < 0x80 {
2920                                 break
2921                         }
2922                 }
2923                 fieldNum := int32(wire >> 3)
2924                 wireType := int(wire & 0x7)
2925                 if wireType == 4 {
2926                         return fmt.Errorf("proto: CustomResourceColumnDefinition: wiretype end group for non-group")
2927                 }
2928                 if fieldNum <= 0 {
2929                         return fmt.Errorf("proto: CustomResourceColumnDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
2930                 }
2931                 switch fieldNum {
2932                 case 1:
2933                         if wireType != 2 {
2934                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
2935                         }
2936                         var stringLen uint64
2937                         for shift := uint(0); ; shift += 7 {
2938                                 if shift >= 64 {
2939                                         return ErrIntOverflowGenerated
2940                                 }
2941                                 if iNdEx >= l {
2942                                         return io.ErrUnexpectedEOF
2943                                 }
2944                                 b := dAtA[iNdEx]
2945                                 iNdEx++
2946                                 stringLen |= (uint64(b) & 0x7F) << shift
2947                                 if b < 0x80 {
2948                                         break
2949                                 }
2950                         }
2951                         intStringLen := int(stringLen)
2952                         if intStringLen < 0 {
2953                                 return ErrInvalidLengthGenerated
2954                         }
2955                         postIndex := iNdEx + intStringLen
2956                         if postIndex > l {
2957                                 return io.ErrUnexpectedEOF
2958                         }
2959                         m.Name = string(dAtA[iNdEx:postIndex])
2960                         iNdEx = postIndex
2961                 case 2:
2962                         if wireType != 2 {
2963                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2964                         }
2965                         var stringLen uint64
2966                         for shift := uint(0); ; shift += 7 {
2967                                 if shift >= 64 {
2968                                         return ErrIntOverflowGenerated
2969                                 }
2970                                 if iNdEx >= l {
2971                                         return io.ErrUnexpectedEOF
2972                                 }
2973                                 b := dAtA[iNdEx]
2974                                 iNdEx++
2975                                 stringLen |= (uint64(b) & 0x7F) << shift
2976                                 if b < 0x80 {
2977                                         break
2978                                 }
2979                         }
2980                         intStringLen := int(stringLen)
2981                         if intStringLen < 0 {
2982                                 return ErrInvalidLengthGenerated
2983                         }
2984                         postIndex := iNdEx + intStringLen
2985                         if postIndex > l {
2986                                 return io.ErrUnexpectedEOF
2987                         }
2988                         m.Type = string(dAtA[iNdEx:postIndex])
2989                         iNdEx = postIndex
2990                 case 3:
2991                         if wireType != 2 {
2992                                 return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
2993                         }
2994                         var stringLen uint64
2995                         for shift := uint(0); ; shift += 7 {
2996                                 if shift >= 64 {
2997                                         return ErrIntOverflowGenerated
2998                                 }
2999                                 if iNdEx >= l {
3000                                         return io.ErrUnexpectedEOF
3001                                 }
3002                                 b := dAtA[iNdEx]
3003                                 iNdEx++
3004                                 stringLen |= (uint64(b) & 0x7F) << shift
3005                                 if b < 0x80 {
3006                                         break
3007                                 }
3008                         }
3009                         intStringLen := int(stringLen)
3010                         if intStringLen < 0 {
3011                                 return ErrInvalidLengthGenerated
3012                         }
3013                         postIndex := iNdEx + intStringLen
3014                         if postIndex > l {
3015                                 return io.ErrUnexpectedEOF
3016                         }
3017                         m.Format = string(dAtA[iNdEx:postIndex])
3018                         iNdEx = postIndex
3019                 case 4:
3020                         if wireType != 2 {
3021                                 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
3022                         }
3023                         var stringLen uint64
3024                         for shift := uint(0); ; shift += 7 {
3025                                 if shift >= 64 {
3026                                         return ErrIntOverflowGenerated
3027                                 }
3028                                 if iNdEx >= l {
3029                                         return io.ErrUnexpectedEOF
3030                                 }
3031                                 b := dAtA[iNdEx]
3032                                 iNdEx++
3033                                 stringLen |= (uint64(b) & 0x7F) << shift
3034                                 if b < 0x80 {
3035                                         break
3036                                 }
3037                         }
3038                         intStringLen := int(stringLen)
3039                         if intStringLen < 0 {
3040                                 return ErrInvalidLengthGenerated
3041                         }
3042                         postIndex := iNdEx + intStringLen
3043                         if postIndex > l {
3044                                 return io.ErrUnexpectedEOF
3045                         }
3046                         m.Description = string(dAtA[iNdEx:postIndex])
3047                         iNdEx = postIndex
3048                 case 5:
3049                         if wireType != 0 {
3050                                 return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
3051                         }
3052                         m.Priority = 0
3053                         for shift := uint(0); ; shift += 7 {
3054                                 if shift >= 64 {
3055                                         return ErrIntOverflowGenerated
3056                                 }
3057                                 if iNdEx >= l {
3058                                         return io.ErrUnexpectedEOF
3059                                 }
3060                                 b := dAtA[iNdEx]
3061                                 iNdEx++
3062                                 m.Priority |= (int32(b) & 0x7F) << shift
3063                                 if b < 0x80 {
3064                                         break
3065                                 }
3066                         }
3067                 case 6:
3068                         if wireType != 2 {
3069                                 return fmt.Errorf("proto: wrong wireType = %d for field JSONPath", wireType)
3070                         }
3071                         var stringLen uint64
3072                         for shift := uint(0); ; shift += 7 {
3073                                 if shift >= 64 {
3074                                         return ErrIntOverflowGenerated
3075                                 }
3076                                 if iNdEx >= l {
3077                                         return io.ErrUnexpectedEOF
3078                                 }
3079                                 b := dAtA[iNdEx]
3080                                 iNdEx++
3081                                 stringLen |= (uint64(b) & 0x7F) << shift
3082                                 if b < 0x80 {
3083                                         break
3084                                 }
3085                         }
3086                         intStringLen := int(stringLen)
3087                         if intStringLen < 0 {
3088                                 return ErrInvalidLengthGenerated
3089                         }
3090                         postIndex := iNdEx + intStringLen
3091                         if postIndex > l {
3092                                 return io.ErrUnexpectedEOF
3093                         }
3094                         m.JSONPath = string(dAtA[iNdEx:postIndex])
3095                         iNdEx = postIndex
3096                 default:
3097                         iNdEx = preIndex
3098                         skippy, err := skipGenerated(dAtA[iNdEx:])
3099                         if err != nil {
3100                                 return err
3101                         }
3102                         if skippy < 0 {
3103                                 return ErrInvalidLengthGenerated
3104                         }
3105                         if (iNdEx + skippy) > l {
3106                                 return io.ErrUnexpectedEOF
3107                         }
3108                         iNdEx += skippy
3109                 }
3110         }
3111
3112         if iNdEx > l {
3113                 return io.ErrUnexpectedEOF
3114         }
3115         return nil
3116 }
3117 func (m *CustomResourceConversion) Unmarshal(dAtA []byte) error {
3118         l := len(dAtA)
3119         iNdEx := 0
3120         for iNdEx < l {
3121                 preIndex := iNdEx
3122                 var wire uint64
3123                 for shift := uint(0); ; shift += 7 {
3124                         if shift >= 64 {
3125                                 return ErrIntOverflowGenerated
3126                         }
3127                         if iNdEx >= l {
3128                                 return io.ErrUnexpectedEOF
3129                         }
3130                         b := dAtA[iNdEx]
3131                         iNdEx++
3132                         wire |= (uint64(b) & 0x7F) << shift
3133                         if b < 0x80 {
3134                                 break
3135                         }
3136                 }
3137                 fieldNum := int32(wire >> 3)
3138                 wireType := int(wire & 0x7)
3139                 if wireType == 4 {
3140                         return fmt.Errorf("proto: CustomResourceConversion: wiretype end group for non-group")
3141                 }
3142                 if fieldNum <= 0 {
3143                         return fmt.Errorf("proto: CustomResourceConversion: illegal tag %d (wire type %d)", fieldNum, wire)
3144                 }
3145                 switch fieldNum {
3146                 case 1:
3147                         if wireType != 2 {
3148                                 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
3149                         }
3150                         var stringLen uint64
3151                         for shift := uint(0); ; shift += 7 {
3152                                 if shift >= 64 {
3153                                         return ErrIntOverflowGenerated
3154                                 }
3155                                 if iNdEx >= l {
3156                                         return io.ErrUnexpectedEOF
3157                                 }
3158                                 b := dAtA[iNdEx]
3159                                 iNdEx++
3160                                 stringLen |= (uint64(b) & 0x7F) << shift
3161                                 if b < 0x80 {
3162                                         break
3163                                 }
3164                         }
3165                         intStringLen := int(stringLen)
3166                         if intStringLen < 0 {
3167                                 return ErrInvalidLengthGenerated
3168                         }
3169                         postIndex := iNdEx + intStringLen
3170                         if postIndex > l {
3171                                 return io.ErrUnexpectedEOF
3172                         }
3173                         m.Strategy = ConversionStrategyType(dAtA[iNdEx:postIndex])
3174                         iNdEx = postIndex
3175                 case 2:
3176                         if wireType != 2 {
3177                                 return fmt.Errorf("proto: wrong wireType = %d for field WebhookClientConfig", wireType)
3178                         }
3179                         var msglen int
3180                         for shift := uint(0); ; shift += 7 {
3181                                 if shift >= 64 {
3182                                         return ErrIntOverflowGenerated
3183                                 }
3184                                 if iNdEx >= l {
3185                                         return io.ErrUnexpectedEOF
3186                                 }
3187                                 b := dAtA[iNdEx]
3188                                 iNdEx++
3189                                 msglen |= (int(b) & 0x7F) << shift
3190                                 if b < 0x80 {
3191                                         break
3192                                 }
3193                         }
3194                         if msglen < 0 {
3195                                 return ErrInvalidLengthGenerated
3196                         }
3197                         postIndex := iNdEx + msglen
3198                         if postIndex > l {
3199                                 return io.ErrUnexpectedEOF
3200                         }
3201                         if m.WebhookClientConfig == nil {
3202                                 m.WebhookClientConfig = &WebhookClientConfig{}
3203                         }
3204                         if err := m.WebhookClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3205                                 return err
3206                         }
3207                         iNdEx = postIndex
3208                 default:
3209                         iNdEx = preIndex
3210                         skippy, err := skipGenerated(dAtA[iNdEx:])
3211                         if err != nil {
3212                                 return err
3213                         }
3214                         if skippy < 0 {
3215                                 return ErrInvalidLengthGenerated
3216                         }
3217                         if (iNdEx + skippy) > l {
3218                                 return io.ErrUnexpectedEOF
3219                         }
3220                         iNdEx += skippy
3221                 }
3222         }
3223
3224         if iNdEx > l {
3225                 return io.ErrUnexpectedEOF
3226         }
3227         return nil
3228 }
3229 func (m *CustomResourceDefinition) Unmarshal(dAtA []byte) error {
3230         l := len(dAtA)
3231         iNdEx := 0
3232         for iNdEx < l {
3233                 preIndex := iNdEx
3234                 var wire uint64
3235                 for shift := uint(0); ; shift += 7 {
3236                         if shift >= 64 {
3237                                 return ErrIntOverflowGenerated
3238                         }
3239                         if iNdEx >= l {
3240                                 return io.ErrUnexpectedEOF
3241                         }
3242                         b := dAtA[iNdEx]
3243                         iNdEx++
3244                         wire |= (uint64(b) & 0x7F) << shift
3245                         if b < 0x80 {
3246                                 break
3247                         }
3248                 }
3249                 fieldNum := int32(wire >> 3)
3250                 wireType := int(wire & 0x7)
3251                 if wireType == 4 {
3252                         return fmt.Errorf("proto: CustomResourceDefinition: wiretype end group for non-group")
3253                 }
3254                 if fieldNum <= 0 {
3255                         return fmt.Errorf("proto: CustomResourceDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
3256                 }
3257                 switch fieldNum {
3258                 case 1:
3259                         if wireType != 2 {
3260                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3261                         }
3262                         var msglen int
3263                         for shift := uint(0); ; shift += 7 {
3264                                 if shift >= 64 {
3265                                         return ErrIntOverflowGenerated
3266                                 }
3267                                 if iNdEx >= l {
3268                                         return io.ErrUnexpectedEOF
3269                                 }
3270                                 b := dAtA[iNdEx]
3271                                 iNdEx++
3272                                 msglen |= (int(b) & 0x7F) << shift
3273                                 if b < 0x80 {
3274                                         break
3275                                 }
3276                         }
3277                         if msglen < 0 {
3278                                 return ErrInvalidLengthGenerated
3279                         }
3280                         postIndex := iNdEx + msglen
3281                         if postIndex > l {
3282                                 return io.ErrUnexpectedEOF
3283                         }
3284                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3285                                 return err
3286                         }
3287                         iNdEx = postIndex
3288                 case 2:
3289                         if wireType != 2 {
3290                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3291                         }
3292                         var msglen int
3293                         for shift := uint(0); ; shift += 7 {
3294                                 if shift >= 64 {
3295                                         return ErrIntOverflowGenerated
3296                                 }
3297                                 if iNdEx >= l {
3298                                         return io.ErrUnexpectedEOF
3299                                 }
3300                                 b := dAtA[iNdEx]
3301                                 iNdEx++
3302                                 msglen |= (int(b) & 0x7F) << shift
3303                                 if b < 0x80 {
3304                                         break
3305                                 }
3306                         }
3307                         if msglen < 0 {
3308                                 return ErrInvalidLengthGenerated
3309                         }
3310                         postIndex := iNdEx + msglen
3311                         if postIndex > l {
3312                                 return io.ErrUnexpectedEOF
3313                         }
3314                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3315                                 return err
3316                         }
3317                         iNdEx = postIndex
3318                 case 3:
3319                         if wireType != 2 {
3320                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3321                         }
3322                         var msglen int
3323                         for shift := uint(0); ; shift += 7 {
3324                                 if shift >= 64 {
3325                                         return ErrIntOverflowGenerated
3326                                 }
3327                                 if iNdEx >= l {
3328                                         return io.ErrUnexpectedEOF
3329                                 }
3330                                 b := dAtA[iNdEx]
3331                                 iNdEx++
3332                                 msglen |= (int(b) & 0x7F) << shift
3333                                 if b < 0x80 {
3334                                         break
3335                                 }
3336                         }
3337                         if msglen < 0 {
3338                                 return ErrInvalidLengthGenerated
3339                         }
3340                         postIndex := iNdEx + msglen
3341                         if postIndex > l {
3342                                 return io.ErrUnexpectedEOF
3343                         }
3344                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3345                                 return err
3346                         }
3347                         iNdEx = postIndex
3348                 default:
3349                         iNdEx = preIndex
3350                         skippy, err := skipGenerated(dAtA[iNdEx:])
3351                         if err != nil {
3352                                 return err
3353                         }
3354                         if skippy < 0 {
3355                                 return ErrInvalidLengthGenerated
3356                         }
3357                         if (iNdEx + skippy) > l {
3358                                 return io.ErrUnexpectedEOF
3359                         }
3360                         iNdEx += skippy
3361                 }
3362         }
3363
3364         if iNdEx > l {
3365                 return io.ErrUnexpectedEOF
3366         }
3367         return nil
3368 }
3369 func (m *CustomResourceDefinitionCondition) Unmarshal(dAtA []byte) error {
3370         l := len(dAtA)
3371         iNdEx := 0
3372         for iNdEx < l {
3373                 preIndex := iNdEx
3374                 var wire uint64
3375                 for shift := uint(0); ; shift += 7 {
3376                         if shift >= 64 {
3377                                 return ErrIntOverflowGenerated
3378                         }
3379                         if iNdEx >= l {
3380                                 return io.ErrUnexpectedEOF
3381                         }
3382                         b := dAtA[iNdEx]
3383                         iNdEx++
3384                         wire |= (uint64(b) & 0x7F) << shift
3385                         if b < 0x80 {
3386                                 break
3387                         }
3388                 }
3389                 fieldNum := int32(wire >> 3)
3390                 wireType := int(wire & 0x7)
3391                 if wireType == 4 {
3392                         return fmt.Errorf("proto: CustomResourceDefinitionCondition: wiretype end group for non-group")
3393                 }
3394                 if fieldNum <= 0 {
3395                         return fmt.Errorf("proto: CustomResourceDefinitionCondition: illegal tag %d (wire type %d)", fieldNum, wire)
3396                 }
3397                 switch fieldNum {
3398                 case 1:
3399                         if wireType != 2 {
3400                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3401                         }
3402                         var stringLen uint64
3403                         for shift := uint(0); ; shift += 7 {
3404                                 if shift >= 64 {
3405                                         return ErrIntOverflowGenerated
3406                                 }
3407                                 if iNdEx >= l {
3408                                         return io.ErrUnexpectedEOF
3409                                 }
3410                                 b := dAtA[iNdEx]
3411                                 iNdEx++
3412                                 stringLen |= (uint64(b) & 0x7F) << shift
3413                                 if b < 0x80 {
3414                                         break
3415                                 }
3416                         }
3417                         intStringLen := int(stringLen)
3418                         if intStringLen < 0 {
3419                                 return ErrInvalidLengthGenerated
3420                         }
3421                         postIndex := iNdEx + intStringLen
3422                         if postIndex > l {
3423                                 return io.ErrUnexpectedEOF
3424                         }
3425                         m.Type = CustomResourceDefinitionConditionType(dAtA[iNdEx:postIndex])
3426                         iNdEx = postIndex
3427                 case 2:
3428                         if wireType != 2 {
3429                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3430                         }
3431                         var stringLen uint64
3432                         for shift := uint(0); ; shift += 7 {
3433                                 if shift >= 64 {
3434                                         return ErrIntOverflowGenerated
3435                                 }
3436                                 if iNdEx >= l {
3437                                         return io.ErrUnexpectedEOF
3438                                 }
3439                                 b := dAtA[iNdEx]
3440                                 iNdEx++
3441                                 stringLen |= (uint64(b) & 0x7F) << shift
3442                                 if b < 0x80 {
3443                                         break
3444                                 }
3445                         }
3446                         intStringLen := int(stringLen)
3447                         if intStringLen < 0 {
3448                                 return ErrInvalidLengthGenerated
3449                         }
3450                         postIndex := iNdEx + intStringLen
3451                         if postIndex > l {
3452                                 return io.ErrUnexpectedEOF
3453                         }
3454                         m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
3455                         iNdEx = postIndex
3456                 case 3:
3457                         if wireType != 2 {
3458                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
3459                         }
3460                         var msglen int
3461                         for shift := uint(0); ; shift += 7 {
3462                                 if shift >= 64 {
3463                                         return ErrIntOverflowGenerated
3464                                 }
3465                                 if iNdEx >= l {
3466                                         return io.ErrUnexpectedEOF
3467                                 }
3468                                 b := dAtA[iNdEx]
3469                                 iNdEx++
3470                                 msglen |= (int(b) & 0x7F) << shift
3471                                 if b < 0x80 {
3472                                         break
3473                                 }
3474                         }
3475                         if msglen < 0 {
3476                                 return ErrInvalidLengthGenerated
3477                         }
3478                         postIndex := iNdEx + msglen
3479                         if postIndex > l {
3480                                 return io.ErrUnexpectedEOF
3481                         }
3482                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3483                                 return err
3484                         }
3485                         iNdEx = postIndex
3486                 case 4:
3487                         if wireType != 2 {
3488                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
3489                         }
3490                         var stringLen uint64
3491                         for shift := uint(0); ; shift += 7 {
3492                                 if shift >= 64 {
3493                                         return ErrIntOverflowGenerated
3494                                 }
3495                                 if iNdEx >= l {
3496                                         return io.ErrUnexpectedEOF
3497                                 }
3498                                 b := dAtA[iNdEx]
3499                                 iNdEx++
3500                                 stringLen |= (uint64(b) & 0x7F) << shift
3501                                 if b < 0x80 {
3502                                         break
3503                                 }
3504                         }
3505                         intStringLen := int(stringLen)
3506                         if intStringLen < 0 {
3507                                 return ErrInvalidLengthGenerated
3508                         }
3509                         postIndex := iNdEx + intStringLen
3510                         if postIndex > l {
3511                                 return io.ErrUnexpectedEOF
3512                         }
3513                         m.Reason = string(dAtA[iNdEx:postIndex])
3514                         iNdEx = postIndex
3515                 case 5:
3516                         if wireType != 2 {
3517                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
3518                         }
3519                         var stringLen uint64
3520                         for shift := uint(0); ; shift += 7 {
3521                                 if shift >= 64 {
3522                                         return ErrIntOverflowGenerated
3523                                 }
3524                                 if iNdEx >= l {
3525                                         return io.ErrUnexpectedEOF
3526                                 }
3527                                 b := dAtA[iNdEx]
3528                                 iNdEx++
3529                                 stringLen |= (uint64(b) & 0x7F) << shift
3530                                 if b < 0x80 {
3531                                         break
3532                                 }
3533                         }
3534                         intStringLen := int(stringLen)
3535                         if intStringLen < 0 {
3536                                 return ErrInvalidLengthGenerated
3537                         }
3538                         postIndex := iNdEx + intStringLen
3539                         if postIndex > l {
3540                                 return io.ErrUnexpectedEOF
3541                         }
3542                         m.Message = string(dAtA[iNdEx:postIndex])
3543                         iNdEx = postIndex
3544                 default:
3545                         iNdEx = preIndex
3546                         skippy, err := skipGenerated(dAtA[iNdEx:])
3547                         if err != nil {
3548                                 return err
3549                         }
3550                         if skippy < 0 {
3551                                 return ErrInvalidLengthGenerated
3552                         }
3553                         if (iNdEx + skippy) > l {
3554                                 return io.ErrUnexpectedEOF
3555                         }
3556                         iNdEx += skippy
3557                 }
3558         }
3559
3560         if iNdEx > l {
3561                 return io.ErrUnexpectedEOF
3562         }
3563         return nil
3564 }
3565 func (m *CustomResourceDefinitionList) Unmarshal(dAtA []byte) error {
3566         l := len(dAtA)
3567         iNdEx := 0
3568         for iNdEx < l {
3569                 preIndex := iNdEx
3570                 var wire uint64
3571                 for shift := uint(0); ; shift += 7 {
3572                         if shift >= 64 {
3573                                 return ErrIntOverflowGenerated
3574                         }
3575                         if iNdEx >= l {
3576                                 return io.ErrUnexpectedEOF
3577                         }
3578                         b := dAtA[iNdEx]
3579                         iNdEx++
3580                         wire |= (uint64(b) & 0x7F) << shift
3581                         if b < 0x80 {
3582                                 break
3583                         }
3584                 }
3585                 fieldNum := int32(wire >> 3)
3586                 wireType := int(wire & 0x7)
3587                 if wireType == 4 {
3588                         return fmt.Errorf("proto: CustomResourceDefinitionList: wiretype end group for non-group")
3589                 }
3590                 if fieldNum <= 0 {
3591                         return fmt.Errorf("proto: CustomResourceDefinitionList: illegal tag %d (wire type %d)", fieldNum, wire)
3592                 }
3593                 switch fieldNum {
3594                 case 1:
3595                         if wireType != 2 {
3596                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3597                         }
3598                         var msglen int
3599                         for shift := uint(0); ; shift += 7 {
3600                                 if shift >= 64 {
3601                                         return ErrIntOverflowGenerated
3602                                 }
3603                                 if iNdEx >= l {
3604                                         return io.ErrUnexpectedEOF
3605                                 }
3606                                 b := dAtA[iNdEx]
3607                                 iNdEx++
3608                                 msglen |= (int(b) & 0x7F) << shift
3609                                 if b < 0x80 {
3610                                         break
3611                                 }
3612                         }
3613                         if msglen < 0 {
3614                                 return ErrInvalidLengthGenerated
3615                         }
3616                         postIndex := iNdEx + msglen
3617                         if postIndex > l {
3618                                 return io.ErrUnexpectedEOF
3619                         }
3620                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3621                                 return err
3622                         }
3623                         iNdEx = postIndex
3624                 case 2:
3625                         if wireType != 2 {
3626                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3627                         }
3628                         var msglen int
3629                         for shift := uint(0); ; shift += 7 {
3630                                 if shift >= 64 {
3631                                         return ErrIntOverflowGenerated
3632                                 }
3633                                 if iNdEx >= l {
3634                                         return io.ErrUnexpectedEOF
3635                                 }
3636                                 b := dAtA[iNdEx]
3637                                 iNdEx++
3638                                 msglen |= (int(b) & 0x7F) << shift
3639                                 if b < 0x80 {
3640                                         break
3641                                 }
3642                         }
3643                         if msglen < 0 {
3644                                 return ErrInvalidLengthGenerated
3645                         }
3646                         postIndex := iNdEx + msglen
3647                         if postIndex > l {
3648                                 return io.ErrUnexpectedEOF
3649                         }
3650                         m.Items = append(m.Items, CustomResourceDefinition{})
3651                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3652                                 return err
3653                         }
3654                         iNdEx = postIndex
3655                 default:
3656                         iNdEx = preIndex
3657                         skippy, err := skipGenerated(dAtA[iNdEx:])
3658                         if err != nil {
3659                                 return err
3660                         }
3661                         if skippy < 0 {
3662                                 return ErrInvalidLengthGenerated
3663                         }
3664                         if (iNdEx + skippy) > l {
3665                                 return io.ErrUnexpectedEOF
3666                         }
3667                         iNdEx += skippy
3668                 }
3669         }
3670
3671         if iNdEx > l {
3672                 return io.ErrUnexpectedEOF
3673         }
3674         return nil
3675 }
3676 func (m *CustomResourceDefinitionNames) Unmarshal(dAtA []byte) error {
3677         l := len(dAtA)
3678         iNdEx := 0
3679         for iNdEx < l {
3680                 preIndex := iNdEx
3681                 var wire uint64
3682                 for shift := uint(0); ; shift += 7 {
3683                         if shift >= 64 {
3684                                 return ErrIntOverflowGenerated
3685                         }
3686                         if iNdEx >= l {
3687                                 return io.ErrUnexpectedEOF
3688                         }
3689                         b := dAtA[iNdEx]
3690                         iNdEx++
3691                         wire |= (uint64(b) & 0x7F) << shift
3692                         if b < 0x80 {
3693                                 break
3694                         }
3695                 }
3696                 fieldNum := int32(wire >> 3)
3697                 wireType := int(wire & 0x7)
3698                 if wireType == 4 {
3699                         return fmt.Errorf("proto: CustomResourceDefinitionNames: wiretype end group for non-group")
3700                 }
3701                 if fieldNum <= 0 {
3702                         return fmt.Errorf("proto: CustomResourceDefinitionNames: illegal tag %d (wire type %d)", fieldNum, wire)
3703                 }
3704                 switch fieldNum {
3705                 case 1:
3706                         if wireType != 2 {
3707                                 return fmt.Errorf("proto: wrong wireType = %d for field Plural", wireType)
3708                         }
3709                         var stringLen uint64
3710                         for shift := uint(0); ; shift += 7 {
3711                                 if shift >= 64 {
3712                                         return ErrIntOverflowGenerated
3713                                 }
3714                                 if iNdEx >= l {
3715                                         return io.ErrUnexpectedEOF
3716                                 }
3717                                 b := dAtA[iNdEx]
3718                                 iNdEx++
3719                                 stringLen |= (uint64(b) & 0x7F) << shift
3720                                 if b < 0x80 {
3721                                         break
3722                                 }
3723                         }
3724                         intStringLen := int(stringLen)
3725                         if intStringLen < 0 {
3726                                 return ErrInvalidLengthGenerated
3727                         }
3728                         postIndex := iNdEx + intStringLen
3729                         if postIndex > l {
3730                                 return io.ErrUnexpectedEOF
3731                         }
3732                         m.Plural = string(dAtA[iNdEx:postIndex])
3733                         iNdEx = postIndex
3734                 case 2:
3735                         if wireType != 2 {
3736                                 return fmt.Errorf("proto: wrong wireType = %d for field Singular", wireType)
3737                         }
3738                         var stringLen uint64
3739                         for shift := uint(0); ; shift += 7 {
3740                                 if shift >= 64 {
3741                                         return ErrIntOverflowGenerated
3742                                 }
3743                                 if iNdEx >= l {
3744                                         return io.ErrUnexpectedEOF
3745                                 }
3746                                 b := dAtA[iNdEx]
3747                                 iNdEx++
3748                                 stringLen |= (uint64(b) & 0x7F) << shift
3749                                 if b < 0x80 {
3750                                         break
3751                                 }
3752                         }
3753                         intStringLen := int(stringLen)
3754                         if intStringLen < 0 {
3755                                 return ErrInvalidLengthGenerated
3756                         }
3757                         postIndex := iNdEx + intStringLen
3758                         if postIndex > l {
3759                                 return io.ErrUnexpectedEOF
3760                         }
3761                         m.Singular = string(dAtA[iNdEx:postIndex])
3762                         iNdEx = postIndex
3763                 case 3:
3764                         if wireType != 2 {
3765                                 return fmt.Errorf("proto: wrong wireType = %d for field ShortNames", wireType)
3766                         }
3767                         var stringLen uint64
3768                         for shift := uint(0); ; shift += 7 {
3769                                 if shift >= 64 {
3770                                         return ErrIntOverflowGenerated
3771                                 }
3772                                 if iNdEx >= l {
3773                                         return io.ErrUnexpectedEOF
3774                                 }
3775                                 b := dAtA[iNdEx]
3776                                 iNdEx++
3777                                 stringLen |= (uint64(b) & 0x7F) << shift
3778                                 if b < 0x80 {
3779                                         break
3780                                 }
3781                         }
3782                         intStringLen := int(stringLen)
3783                         if intStringLen < 0 {
3784                                 return ErrInvalidLengthGenerated
3785                         }
3786                         postIndex := iNdEx + intStringLen
3787                         if postIndex > l {
3788                                 return io.ErrUnexpectedEOF
3789                         }
3790                         m.ShortNames = append(m.ShortNames, string(dAtA[iNdEx:postIndex]))
3791                         iNdEx = postIndex
3792                 case 4:
3793                         if wireType != 2 {
3794                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
3795                         }
3796                         var stringLen uint64
3797                         for shift := uint(0); ; shift += 7 {
3798                                 if shift >= 64 {
3799                                         return ErrIntOverflowGenerated
3800                                 }
3801                                 if iNdEx >= l {
3802                                         return io.ErrUnexpectedEOF
3803                                 }
3804                                 b := dAtA[iNdEx]
3805                                 iNdEx++
3806                                 stringLen |= (uint64(b) & 0x7F) << shift
3807                                 if b < 0x80 {
3808                                         break
3809                                 }
3810                         }
3811                         intStringLen := int(stringLen)
3812                         if intStringLen < 0 {
3813                                 return ErrInvalidLengthGenerated
3814                         }
3815                         postIndex := iNdEx + intStringLen
3816                         if postIndex > l {
3817                                 return io.ErrUnexpectedEOF
3818                         }
3819                         m.Kind = string(dAtA[iNdEx:postIndex])
3820                         iNdEx = postIndex
3821                 case 5:
3822                         if wireType != 2 {
3823                                 return fmt.Errorf("proto: wrong wireType = %d for field ListKind", wireType)
3824                         }
3825                         var stringLen uint64
3826                         for shift := uint(0); ; shift += 7 {
3827                                 if shift >= 64 {
3828                                         return ErrIntOverflowGenerated
3829                                 }
3830                                 if iNdEx >= l {
3831                                         return io.ErrUnexpectedEOF
3832                                 }
3833                                 b := dAtA[iNdEx]
3834                                 iNdEx++
3835                                 stringLen |= (uint64(b) & 0x7F) << shift
3836                                 if b < 0x80 {
3837                                         break
3838                                 }
3839                         }
3840                         intStringLen := int(stringLen)
3841                         if intStringLen < 0 {
3842                                 return ErrInvalidLengthGenerated
3843                         }
3844                         postIndex := iNdEx + intStringLen
3845                         if postIndex > l {
3846                                 return io.ErrUnexpectedEOF
3847                         }
3848                         m.ListKind = string(dAtA[iNdEx:postIndex])
3849                         iNdEx = postIndex
3850                 case 6:
3851                         if wireType != 2 {
3852                                 return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType)
3853                         }
3854                         var stringLen uint64
3855                         for shift := uint(0); ; shift += 7 {
3856                                 if shift >= 64 {
3857                                         return ErrIntOverflowGenerated
3858                                 }
3859                                 if iNdEx >= l {
3860                                         return io.ErrUnexpectedEOF
3861                                 }
3862                                 b := dAtA[iNdEx]
3863                                 iNdEx++
3864                                 stringLen |= (uint64(b) & 0x7F) << shift
3865                                 if b < 0x80 {
3866                                         break
3867                                 }
3868                         }
3869                         intStringLen := int(stringLen)
3870                         if intStringLen < 0 {
3871                                 return ErrInvalidLengthGenerated
3872                         }
3873                         postIndex := iNdEx + intStringLen
3874                         if postIndex > l {
3875                                 return io.ErrUnexpectedEOF
3876                         }
3877                         m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex]))
3878                         iNdEx = postIndex
3879                 default:
3880                         iNdEx = preIndex
3881                         skippy, err := skipGenerated(dAtA[iNdEx:])
3882                         if err != nil {
3883                                 return err
3884                         }
3885                         if skippy < 0 {
3886                                 return ErrInvalidLengthGenerated
3887                         }
3888                         if (iNdEx + skippy) > l {
3889                                 return io.ErrUnexpectedEOF
3890                         }
3891                         iNdEx += skippy
3892                 }
3893         }
3894
3895         if iNdEx > l {
3896                 return io.ErrUnexpectedEOF
3897         }
3898         return nil
3899 }
3900 func (m *CustomResourceDefinitionSpec) Unmarshal(dAtA []byte) error {
3901         l := len(dAtA)
3902         iNdEx := 0
3903         for iNdEx < l {
3904                 preIndex := iNdEx
3905                 var wire uint64
3906                 for shift := uint(0); ; shift += 7 {
3907                         if shift >= 64 {
3908                                 return ErrIntOverflowGenerated
3909                         }
3910                         if iNdEx >= l {
3911                                 return io.ErrUnexpectedEOF
3912                         }
3913                         b := dAtA[iNdEx]
3914                         iNdEx++
3915                         wire |= (uint64(b) & 0x7F) << shift
3916                         if b < 0x80 {
3917                                 break
3918                         }
3919                 }
3920                 fieldNum := int32(wire >> 3)
3921                 wireType := int(wire & 0x7)
3922                 if wireType == 4 {
3923                         return fmt.Errorf("proto: CustomResourceDefinitionSpec: wiretype end group for non-group")
3924                 }
3925                 if fieldNum <= 0 {
3926                         return fmt.Errorf("proto: CustomResourceDefinitionSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3927                 }
3928                 switch fieldNum {
3929                 case 1:
3930                         if wireType != 2 {
3931                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
3932                         }
3933                         var stringLen uint64
3934                         for shift := uint(0); ; shift += 7 {
3935                                 if shift >= 64 {
3936                                         return ErrIntOverflowGenerated
3937                                 }
3938                                 if iNdEx >= l {
3939                                         return io.ErrUnexpectedEOF
3940                                 }
3941                                 b := dAtA[iNdEx]
3942                                 iNdEx++
3943                                 stringLen |= (uint64(b) & 0x7F) << shift
3944                                 if b < 0x80 {
3945                                         break
3946                                 }
3947                         }
3948                         intStringLen := int(stringLen)
3949                         if intStringLen < 0 {
3950                                 return ErrInvalidLengthGenerated
3951                         }
3952                         postIndex := iNdEx + intStringLen
3953                         if postIndex > l {
3954                                 return io.ErrUnexpectedEOF
3955                         }
3956                         m.Group = string(dAtA[iNdEx:postIndex])
3957                         iNdEx = postIndex
3958                 case 2:
3959                         if wireType != 2 {
3960                                 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
3961                         }
3962                         var stringLen uint64
3963                         for shift := uint(0); ; shift += 7 {
3964                                 if shift >= 64 {
3965                                         return ErrIntOverflowGenerated
3966                                 }
3967                                 if iNdEx >= l {
3968                                         return io.ErrUnexpectedEOF
3969                                 }
3970                                 b := dAtA[iNdEx]
3971                                 iNdEx++
3972                                 stringLen |= (uint64(b) & 0x7F) << shift
3973                                 if b < 0x80 {
3974                                         break
3975                                 }
3976                         }
3977                         intStringLen := int(stringLen)
3978                         if intStringLen < 0 {
3979                                 return ErrInvalidLengthGenerated
3980                         }
3981                         postIndex := iNdEx + intStringLen
3982                         if postIndex > l {
3983                                 return io.ErrUnexpectedEOF
3984                         }
3985                         m.Version = string(dAtA[iNdEx:postIndex])
3986                         iNdEx = postIndex
3987                 case 3:
3988                         if wireType != 2 {
3989                                 return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
3990                         }
3991                         var msglen int
3992                         for shift := uint(0); ; shift += 7 {
3993                                 if shift >= 64 {
3994                                         return ErrIntOverflowGenerated
3995                                 }
3996                                 if iNdEx >= l {
3997                                         return io.ErrUnexpectedEOF
3998                                 }
3999                                 b := dAtA[iNdEx]
4000                                 iNdEx++
4001                                 msglen |= (int(b) & 0x7F) << shift
4002                                 if b < 0x80 {
4003                                         break
4004                                 }
4005                         }
4006                         if msglen < 0 {
4007                                 return ErrInvalidLengthGenerated
4008                         }
4009                         postIndex := iNdEx + msglen
4010                         if postIndex > l {
4011                                 return io.ErrUnexpectedEOF
4012                         }
4013                         if err := m.Names.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4014                                 return err
4015                         }
4016                         iNdEx = postIndex
4017                 case 4:
4018                         if wireType != 2 {
4019                                 return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
4020                         }
4021                         var stringLen uint64
4022                         for shift := uint(0); ; shift += 7 {
4023                                 if shift >= 64 {
4024                                         return ErrIntOverflowGenerated
4025                                 }
4026                                 if iNdEx >= l {
4027                                         return io.ErrUnexpectedEOF
4028                                 }
4029                                 b := dAtA[iNdEx]
4030                                 iNdEx++
4031                                 stringLen |= (uint64(b) & 0x7F) << shift
4032                                 if b < 0x80 {
4033                                         break
4034                                 }
4035                         }
4036                         intStringLen := int(stringLen)
4037                         if intStringLen < 0 {
4038                                 return ErrInvalidLengthGenerated
4039                         }
4040                         postIndex := iNdEx + intStringLen
4041                         if postIndex > l {
4042                                 return io.ErrUnexpectedEOF
4043                         }
4044                         m.Scope = ResourceScope(dAtA[iNdEx:postIndex])
4045                         iNdEx = postIndex
4046                 case 5:
4047                         if wireType != 2 {
4048                                 return fmt.Errorf("proto: wrong wireType = %d for field Validation", wireType)
4049                         }
4050                         var msglen int
4051                         for shift := uint(0); ; shift += 7 {
4052                                 if shift >= 64 {
4053                                         return ErrIntOverflowGenerated
4054                                 }
4055                                 if iNdEx >= l {
4056                                         return io.ErrUnexpectedEOF
4057                                 }
4058                                 b := dAtA[iNdEx]
4059                                 iNdEx++
4060                                 msglen |= (int(b) & 0x7F) << shift
4061                                 if b < 0x80 {
4062                                         break
4063                                 }
4064                         }
4065                         if msglen < 0 {
4066                                 return ErrInvalidLengthGenerated
4067                         }
4068                         postIndex := iNdEx + msglen
4069                         if postIndex > l {
4070                                 return io.ErrUnexpectedEOF
4071                         }
4072                         if m.Validation == nil {
4073                                 m.Validation = &CustomResourceValidation{}
4074                         }
4075                         if err := m.Validation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4076                                 return err
4077                         }
4078                         iNdEx = postIndex
4079                 case 6:
4080                         if wireType != 2 {
4081                                 return fmt.Errorf("proto: wrong wireType = %d for field Subresources", wireType)
4082                         }
4083                         var msglen int
4084                         for shift := uint(0); ; shift += 7 {
4085                                 if shift >= 64 {
4086                                         return ErrIntOverflowGenerated
4087                                 }
4088                                 if iNdEx >= l {
4089                                         return io.ErrUnexpectedEOF
4090                                 }
4091                                 b := dAtA[iNdEx]
4092                                 iNdEx++
4093                                 msglen |= (int(b) & 0x7F) << shift
4094                                 if b < 0x80 {
4095                                         break
4096                                 }
4097                         }
4098                         if msglen < 0 {
4099                                 return ErrInvalidLengthGenerated
4100                         }
4101                         postIndex := iNdEx + msglen
4102                         if postIndex > l {
4103                                 return io.ErrUnexpectedEOF
4104                         }
4105                         if m.Subresources == nil {
4106                                 m.Subresources = &CustomResourceSubresources{}
4107                         }
4108                         if err := m.Subresources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4109                                 return err
4110                         }
4111                         iNdEx = postIndex
4112                 case 7:
4113                         if wireType != 2 {
4114                                 return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
4115                         }
4116                         var msglen int
4117                         for shift := uint(0); ; shift += 7 {
4118                                 if shift >= 64 {
4119                                         return ErrIntOverflowGenerated
4120                                 }
4121                                 if iNdEx >= l {
4122                                         return io.ErrUnexpectedEOF
4123                                 }
4124                                 b := dAtA[iNdEx]
4125                                 iNdEx++
4126                                 msglen |= (int(b) & 0x7F) << shift
4127                                 if b < 0x80 {
4128                                         break
4129                                 }
4130                         }
4131                         if msglen < 0 {
4132                                 return ErrInvalidLengthGenerated
4133                         }
4134                         postIndex := iNdEx + msglen
4135                         if postIndex > l {
4136                                 return io.ErrUnexpectedEOF
4137                         }
4138                         m.Versions = append(m.Versions, CustomResourceDefinitionVersion{})
4139                         if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4140                                 return err
4141                         }
4142                         iNdEx = postIndex
4143                 case 8:
4144                         if wireType != 2 {
4145                                 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalPrinterColumns", wireType)
4146                         }
4147                         var msglen int
4148                         for shift := uint(0); ; shift += 7 {
4149                                 if shift >= 64 {
4150                                         return ErrIntOverflowGenerated
4151                                 }
4152                                 if iNdEx >= l {
4153                                         return io.ErrUnexpectedEOF
4154                                 }
4155                                 b := dAtA[iNdEx]
4156                                 iNdEx++
4157                                 msglen |= (int(b) & 0x7F) << shift
4158                                 if b < 0x80 {
4159                                         break
4160                                 }
4161                         }
4162                         if msglen < 0 {
4163                                 return ErrInvalidLengthGenerated
4164                         }
4165                         postIndex := iNdEx + msglen
4166                         if postIndex > l {
4167                                 return io.ErrUnexpectedEOF
4168                         }
4169                         m.AdditionalPrinterColumns = append(m.AdditionalPrinterColumns, CustomResourceColumnDefinition{})
4170                         if err := m.AdditionalPrinterColumns[len(m.AdditionalPrinterColumns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4171                                 return err
4172                         }
4173                         iNdEx = postIndex
4174                 case 9:
4175                         if wireType != 2 {
4176                                 return fmt.Errorf("proto: wrong wireType = %d for field Conversion", wireType)
4177                         }
4178                         var msglen int
4179                         for shift := uint(0); ; shift += 7 {
4180                                 if shift >= 64 {
4181                                         return ErrIntOverflowGenerated
4182                                 }
4183                                 if iNdEx >= l {
4184                                         return io.ErrUnexpectedEOF
4185                                 }
4186                                 b := dAtA[iNdEx]
4187                                 iNdEx++
4188                                 msglen |= (int(b) & 0x7F) << shift
4189                                 if b < 0x80 {
4190                                         break
4191                                 }
4192                         }
4193                         if msglen < 0 {
4194                                 return ErrInvalidLengthGenerated
4195                         }
4196                         postIndex := iNdEx + msglen
4197                         if postIndex > l {
4198                                 return io.ErrUnexpectedEOF
4199                         }
4200                         if m.Conversion == nil {
4201                                 m.Conversion = &CustomResourceConversion{}
4202                         }
4203                         if err := m.Conversion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4204                                 return err
4205                         }
4206                         iNdEx = postIndex
4207                 default:
4208                         iNdEx = preIndex
4209                         skippy, err := skipGenerated(dAtA[iNdEx:])
4210                         if err != nil {
4211                                 return err
4212                         }
4213                         if skippy < 0 {
4214                                 return ErrInvalidLengthGenerated
4215                         }
4216                         if (iNdEx + skippy) > l {
4217                                 return io.ErrUnexpectedEOF
4218                         }
4219                         iNdEx += skippy
4220                 }
4221         }
4222
4223         if iNdEx > l {
4224                 return io.ErrUnexpectedEOF
4225         }
4226         return nil
4227 }
4228 func (m *CustomResourceDefinitionStatus) Unmarshal(dAtA []byte) error {
4229         l := len(dAtA)
4230         iNdEx := 0
4231         for iNdEx < l {
4232                 preIndex := iNdEx
4233                 var wire uint64
4234                 for shift := uint(0); ; shift += 7 {
4235                         if shift >= 64 {
4236                                 return ErrIntOverflowGenerated
4237                         }
4238                         if iNdEx >= l {
4239                                 return io.ErrUnexpectedEOF
4240                         }
4241                         b := dAtA[iNdEx]
4242                         iNdEx++
4243                         wire |= (uint64(b) & 0x7F) << shift
4244                         if b < 0x80 {
4245                                 break
4246                         }
4247                 }
4248                 fieldNum := int32(wire >> 3)
4249                 wireType := int(wire & 0x7)
4250                 if wireType == 4 {
4251                         return fmt.Errorf("proto: CustomResourceDefinitionStatus: wiretype end group for non-group")
4252                 }
4253                 if fieldNum <= 0 {
4254                         return fmt.Errorf("proto: CustomResourceDefinitionStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4255                 }
4256                 switch fieldNum {
4257                 case 1:
4258                         if wireType != 2 {
4259                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
4260                         }
4261                         var msglen int
4262                         for shift := uint(0); ; shift += 7 {
4263                                 if shift >= 64 {
4264                                         return ErrIntOverflowGenerated
4265                                 }
4266                                 if iNdEx >= l {
4267                                         return io.ErrUnexpectedEOF
4268                                 }
4269                                 b := dAtA[iNdEx]
4270                                 iNdEx++
4271                                 msglen |= (int(b) & 0x7F) << shift
4272                                 if b < 0x80 {
4273                                         break
4274                                 }
4275                         }
4276                         if msglen < 0 {
4277                                 return ErrInvalidLengthGenerated
4278                         }
4279                         postIndex := iNdEx + msglen
4280                         if postIndex > l {
4281                                 return io.ErrUnexpectedEOF
4282                         }
4283                         m.Conditions = append(m.Conditions, CustomResourceDefinitionCondition{})
4284                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4285                                 return err
4286                         }
4287                         iNdEx = postIndex
4288                 case 2:
4289                         if wireType != 2 {
4290                                 return fmt.Errorf("proto: wrong wireType = %d for field AcceptedNames", wireType)
4291                         }
4292                         var msglen int
4293                         for shift := uint(0); ; shift += 7 {
4294                                 if shift >= 64 {
4295                                         return ErrIntOverflowGenerated
4296                                 }
4297                                 if iNdEx >= l {
4298                                         return io.ErrUnexpectedEOF
4299                                 }
4300                                 b := dAtA[iNdEx]
4301                                 iNdEx++
4302                                 msglen |= (int(b) & 0x7F) << shift
4303                                 if b < 0x80 {
4304                                         break
4305                                 }
4306                         }
4307                         if msglen < 0 {
4308                                 return ErrInvalidLengthGenerated
4309                         }
4310                         postIndex := iNdEx + msglen
4311                         if postIndex > l {
4312                                 return io.ErrUnexpectedEOF
4313                         }
4314                         if err := m.AcceptedNames.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4315                                 return err
4316                         }
4317                         iNdEx = postIndex
4318                 case 3:
4319                         if wireType != 2 {
4320                                 return fmt.Errorf("proto: wrong wireType = %d for field StoredVersions", wireType)
4321                         }
4322                         var stringLen uint64
4323                         for shift := uint(0); ; shift += 7 {
4324                                 if shift >= 64 {
4325                                         return ErrIntOverflowGenerated
4326                                 }
4327                                 if iNdEx >= l {
4328                                         return io.ErrUnexpectedEOF
4329                                 }
4330                                 b := dAtA[iNdEx]
4331                                 iNdEx++
4332                                 stringLen |= (uint64(b) & 0x7F) << shift
4333                                 if b < 0x80 {
4334                                         break
4335                                 }
4336                         }
4337                         intStringLen := int(stringLen)
4338                         if intStringLen < 0 {
4339                                 return ErrInvalidLengthGenerated
4340                         }
4341                         postIndex := iNdEx + intStringLen
4342                         if postIndex > l {
4343                                 return io.ErrUnexpectedEOF
4344                         }
4345                         m.StoredVersions = append(m.StoredVersions, string(dAtA[iNdEx:postIndex]))
4346                         iNdEx = postIndex
4347                 default:
4348                         iNdEx = preIndex
4349                         skippy, err := skipGenerated(dAtA[iNdEx:])
4350                         if err != nil {
4351                                 return err
4352                         }
4353                         if skippy < 0 {
4354                                 return ErrInvalidLengthGenerated
4355                         }
4356                         if (iNdEx + skippy) > l {
4357                                 return io.ErrUnexpectedEOF
4358                         }
4359                         iNdEx += skippy
4360                 }
4361         }
4362
4363         if iNdEx > l {
4364                 return io.ErrUnexpectedEOF
4365         }
4366         return nil
4367 }
4368 func (m *CustomResourceDefinitionVersion) Unmarshal(dAtA []byte) error {
4369         l := len(dAtA)
4370         iNdEx := 0
4371         for iNdEx < l {
4372                 preIndex := iNdEx
4373                 var wire uint64
4374                 for shift := uint(0); ; shift += 7 {
4375                         if shift >= 64 {
4376                                 return ErrIntOverflowGenerated
4377                         }
4378                         if iNdEx >= l {
4379                                 return io.ErrUnexpectedEOF
4380                         }
4381                         b := dAtA[iNdEx]
4382                         iNdEx++
4383                         wire |= (uint64(b) & 0x7F) << shift
4384                         if b < 0x80 {
4385                                 break
4386                         }
4387                 }
4388                 fieldNum := int32(wire >> 3)
4389                 wireType := int(wire & 0x7)
4390                 if wireType == 4 {
4391                         return fmt.Errorf("proto: CustomResourceDefinitionVersion: wiretype end group for non-group")
4392                 }
4393                 if fieldNum <= 0 {
4394                         return fmt.Errorf("proto: CustomResourceDefinitionVersion: illegal tag %d (wire type %d)", fieldNum, wire)
4395                 }
4396                 switch fieldNum {
4397                 case 1:
4398                         if wireType != 2 {
4399                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4400                         }
4401                         var stringLen uint64
4402                         for shift := uint(0); ; shift += 7 {
4403                                 if shift >= 64 {
4404                                         return ErrIntOverflowGenerated
4405                                 }
4406                                 if iNdEx >= l {
4407                                         return io.ErrUnexpectedEOF
4408                                 }
4409                                 b := dAtA[iNdEx]
4410                                 iNdEx++
4411                                 stringLen |= (uint64(b) & 0x7F) << shift
4412                                 if b < 0x80 {
4413                                         break
4414                                 }
4415                         }
4416                         intStringLen := int(stringLen)
4417                         if intStringLen < 0 {
4418                                 return ErrInvalidLengthGenerated
4419                         }
4420                         postIndex := iNdEx + intStringLen
4421                         if postIndex > l {
4422                                 return io.ErrUnexpectedEOF
4423                         }
4424                         m.Name = string(dAtA[iNdEx:postIndex])
4425                         iNdEx = postIndex
4426                 case 2:
4427                         if wireType != 0 {
4428                                 return fmt.Errorf("proto: wrong wireType = %d for field Served", wireType)
4429                         }
4430                         var v int
4431                         for shift := uint(0); ; shift += 7 {
4432                                 if shift >= 64 {
4433                                         return ErrIntOverflowGenerated
4434                                 }
4435                                 if iNdEx >= l {
4436                                         return io.ErrUnexpectedEOF
4437                                 }
4438                                 b := dAtA[iNdEx]
4439                                 iNdEx++
4440                                 v |= (int(b) & 0x7F) << shift
4441                                 if b < 0x80 {
4442                                         break
4443                                 }
4444                         }
4445                         m.Served = bool(v != 0)
4446                 case 3:
4447                         if wireType != 0 {
4448                                 return fmt.Errorf("proto: wrong wireType = %d for field Storage", wireType)
4449                         }
4450                         var v int
4451                         for shift := uint(0); ; shift += 7 {
4452                                 if shift >= 64 {
4453                                         return ErrIntOverflowGenerated
4454                                 }
4455                                 if iNdEx >= l {
4456                                         return io.ErrUnexpectedEOF
4457                                 }
4458                                 b := dAtA[iNdEx]
4459                                 iNdEx++
4460                                 v |= (int(b) & 0x7F) << shift
4461                                 if b < 0x80 {
4462                                         break
4463                                 }
4464                         }
4465                         m.Storage = bool(v != 0)
4466                 case 4:
4467                         if wireType != 2 {
4468                                 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
4469                         }
4470                         var msglen int
4471                         for shift := uint(0); ; shift += 7 {
4472                                 if shift >= 64 {
4473                                         return ErrIntOverflowGenerated
4474                                 }
4475                                 if iNdEx >= l {
4476                                         return io.ErrUnexpectedEOF
4477                                 }
4478                                 b := dAtA[iNdEx]
4479                                 iNdEx++
4480                                 msglen |= (int(b) & 0x7F) << shift
4481                                 if b < 0x80 {
4482                                         break
4483                                 }
4484                         }
4485                         if msglen < 0 {
4486                                 return ErrInvalidLengthGenerated
4487                         }
4488                         postIndex := iNdEx + msglen
4489                         if postIndex > l {
4490                                 return io.ErrUnexpectedEOF
4491                         }
4492                         if m.Schema == nil {
4493                                 m.Schema = &CustomResourceValidation{}
4494                         }
4495                         if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4496                                 return err
4497                         }
4498                         iNdEx = postIndex
4499                 case 5:
4500                         if wireType != 2 {
4501                                 return fmt.Errorf("proto: wrong wireType = %d for field Subresources", wireType)
4502                         }
4503                         var msglen int
4504                         for shift := uint(0); ; shift += 7 {
4505                                 if shift >= 64 {
4506                                         return ErrIntOverflowGenerated
4507                                 }
4508                                 if iNdEx >= l {
4509                                         return io.ErrUnexpectedEOF
4510                                 }
4511                                 b := dAtA[iNdEx]
4512                                 iNdEx++
4513                                 msglen |= (int(b) & 0x7F) << shift
4514                                 if b < 0x80 {
4515                                         break
4516                                 }
4517                         }
4518                         if msglen < 0 {
4519                                 return ErrInvalidLengthGenerated
4520                         }
4521                         postIndex := iNdEx + msglen
4522                         if postIndex > l {
4523                                 return io.ErrUnexpectedEOF
4524                         }
4525                         if m.Subresources == nil {
4526                                 m.Subresources = &CustomResourceSubresources{}
4527                         }
4528                         if err := m.Subresources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4529                                 return err
4530                         }
4531                         iNdEx = postIndex
4532                 case 6:
4533                         if wireType != 2 {
4534                                 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalPrinterColumns", wireType)
4535                         }
4536                         var msglen int
4537                         for shift := uint(0); ; shift += 7 {
4538                                 if shift >= 64 {
4539                                         return ErrIntOverflowGenerated
4540                                 }
4541                                 if iNdEx >= l {
4542                                         return io.ErrUnexpectedEOF
4543                                 }
4544                                 b := dAtA[iNdEx]
4545                                 iNdEx++
4546                                 msglen |= (int(b) & 0x7F) << shift
4547                                 if b < 0x80 {
4548                                         break
4549                                 }
4550                         }
4551                         if msglen < 0 {
4552                                 return ErrInvalidLengthGenerated
4553                         }
4554                         postIndex := iNdEx + msglen
4555                         if postIndex > l {
4556                                 return io.ErrUnexpectedEOF
4557                         }
4558                         m.AdditionalPrinterColumns = append(m.AdditionalPrinterColumns, CustomResourceColumnDefinition{})
4559                         if err := m.AdditionalPrinterColumns[len(m.AdditionalPrinterColumns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4560                                 return err
4561                         }
4562                         iNdEx = postIndex
4563                 default:
4564                         iNdEx = preIndex
4565                         skippy, err := skipGenerated(dAtA[iNdEx:])
4566                         if err != nil {
4567                                 return err
4568                         }
4569                         if skippy < 0 {
4570                                 return ErrInvalidLengthGenerated
4571                         }
4572                         if (iNdEx + skippy) > l {
4573                                 return io.ErrUnexpectedEOF
4574                         }
4575                         iNdEx += skippy
4576                 }
4577         }
4578
4579         if iNdEx > l {
4580                 return io.ErrUnexpectedEOF
4581         }
4582         return nil
4583 }
4584 func (m *CustomResourceSubresourceScale) Unmarshal(dAtA []byte) error {
4585         l := len(dAtA)
4586         iNdEx := 0
4587         for iNdEx < l {
4588                 preIndex := iNdEx
4589                 var wire uint64
4590                 for shift := uint(0); ; shift += 7 {
4591                         if shift >= 64 {
4592                                 return ErrIntOverflowGenerated
4593                         }
4594                         if iNdEx >= l {
4595                                 return io.ErrUnexpectedEOF
4596                         }
4597                         b := dAtA[iNdEx]
4598                         iNdEx++
4599                         wire |= (uint64(b) & 0x7F) << shift
4600                         if b < 0x80 {
4601                                 break
4602                         }
4603                 }
4604                 fieldNum := int32(wire >> 3)
4605                 wireType := int(wire & 0x7)
4606                 if wireType == 4 {
4607                         return fmt.Errorf("proto: CustomResourceSubresourceScale: wiretype end group for non-group")
4608                 }
4609                 if fieldNum <= 0 {
4610                         return fmt.Errorf("proto: CustomResourceSubresourceScale: illegal tag %d (wire type %d)", fieldNum, wire)
4611                 }
4612                 switch fieldNum {
4613                 case 1:
4614                         if wireType != 2 {
4615                                 return fmt.Errorf("proto: wrong wireType = %d for field SpecReplicasPath", wireType)
4616                         }
4617                         var stringLen uint64
4618                         for shift := uint(0); ; shift += 7 {
4619                                 if shift >= 64 {
4620                                         return ErrIntOverflowGenerated
4621                                 }
4622                                 if iNdEx >= l {
4623                                         return io.ErrUnexpectedEOF
4624                                 }
4625                                 b := dAtA[iNdEx]
4626                                 iNdEx++
4627                                 stringLen |= (uint64(b) & 0x7F) << shift
4628                                 if b < 0x80 {
4629                                         break
4630                                 }
4631                         }
4632                         intStringLen := int(stringLen)
4633                         if intStringLen < 0 {
4634                                 return ErrInvalidLengthGenerated
4635                         }
4636                         postIndex := iNdEx + intStringLen
4637                         if postIndex > l {
4638                                 return io.ErrUnexpectedEOF
4639                         }
4640                         m.SpecReplicasPath = string(dAtA[iNdEx:postIndex])
4641                         iNdEx = postIndex
4642                 case 2:
4643                         if wireType != 2 {
4644                                 return fmt.Errorf("proto: wrong wireType = %d for field StatusReplicasPath", wireType)
4645                         }
4646                         var stringLen uint64
4647                         for shift := uint(0); ; shift += 7 {
4648                                 if shift >= 64 {
4649                                         return ErrIntOverflowGenerated
4650                                 }
4651                                 if iNdEx >= l {
4652                                         return io.ErrUnexpectedEOF
4653                                 }
4654                                 b := dAtA[iNdEx]
4655                                 iNdEx++
4656                                 stringLen |= (uint64(b) & 0x7F) << shift
4657                                 if b < 0x80 {
4658                                         break
4659                                 }
4660                         }
4661                         intStringLen := int(stringLen)
4662                         if intStringLen < 0 {
4663                                 return ErrInvalidLengthGenerated
4664                         }
4665                         postIndex := iNdEx + intStringLen
4666                         if postIndex > l {
4667                                 return io.ErrUnexpectedEOF
4668                         }
4669                         m.StatusReplicasPath = string(dAtA[iNdEx:postIndex])
4670                         iNdEx = postIndex
4671                 case 3:
4672                         if wireType != 2 {
4673                                 return fmt.Errorf("proto: wrong wireType = %d for field LabelSelectorPath", wireType)
4674                         }
4675                         var stringLen uint64
4676                         for shift := uint(0); ; shift += 7 {
4677                                 if shift >= 64 {
4678                                         return ErrIntOverflowGenerated
4679                                 }
4680                                 if iNdEx >= l {
4681                                         return io.ErrUnexpectedEOF
4682                                 }
4683                                 b := dAtA[iNdEx]
4684                                 iNdEx++
4685                                 stringLen |= (uint64(b) & 0x7F) << shift
4686                                 if b < 0x80 {
4687                                         break
4688                                 }
4689                         }
4690                         intStringLen := int(stringLen)
4691                         if intStringLen < 0 {
4692                                 return ErrInvalidLengthGenerated
4693                         }
4694                         postIndex := iNdEx + intStringLen
4695                         if postIndex > l {
4696                                 return io.ErrUnexpectedEOF
4697                         }
4698                         s := string(dAtA[iNdEx:postIndex])
4699                         m.LabelSelectorPath = &s
4700                         iNdEx = postIndex
4701                 default:
4702                         iNdEx = preIndex
4703                         skippy, err := skipGenerated(dAtA[iNdEx:])
4704                         if err != nil {
4705                                 return err
4706                         }
4707                         if skippy < 0 {
4708                                 return ErrInvalidLengthGenerated
4709                         }
4710                         if (iNdEx + skippy) > l {
4711                                 return io.ErrUnexpectedEOF
4712                         }
4713                         iNdEx += skippy
4714                 }
4715         }
4716
4717         if iNdEx > l {
4718                 return io.ErrUnexpectedEOF
4719         }
4720         return nil
4721 }
4722 func (m *CustomResourceSubresourceStatus) Unmarshal(dAtA []byte) error {
4723         l := len(dAtA)
4724         iNdEx := 0
4725         for iNdEx < l {
4726                 preIndex := iNdEx
4727                 var wire uint64
4728                 for shift := uint(0); ; shift += 7 {
4729                         if shift >= 64 {
4730                                 return ErrIntOverflowGenerated
4731                         }
4732                         if iNdEx >= l {
4733                                 return io.ErrUnexpectedEOF
4734                         }
4735                         b := dAtA[iNdEx]
4736                         iNdEx++
4737                         wire |= (uint64(b) & 0x7F) << shift
4738                         if b < 0x80 {
4739                                 break
4740                         }
4741                 }
4742                 fieldNum := int32(wire >> 3)
4743                 wireType := int(wire & 0x7)
4744                 if wireType == 4 {
4745                         return fmt.Errorf("proto: CustomResourceSubresourceStatus: wiretype end group for non-group")
4746                 }
4747                 if fieldNum <= 0 {
4748                         return fmt.Errorf("proto: CustomResourceSubresourceStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4749                 }
4750                 switch fieldNum {
4751                 default:
4752                         iNdEx = preIndex
4753                         skippy, err := skipGenerated(dAtA[iNdEx:])
4754                         if err != nil {
4755                                 return err
4756                         }
4757                         if skippy < 0 {
4758                                 return ErrInvalidLengthGenerated
4759                         }
4760                         if (iNdEx + skippy) > l {
4761                                 return io.ErrUnexpectedEOF
4762                         }
4763                         iNdEx += skippy
4764                 }
4765         }
4766
4767         if iNdEx > l {
4768                 return io.ErrUnexpectedEOF
4769         }
4770         return nil
4771 }
4772 func (m *CustomResourceSubresources) Unmarshal(dAtA []byte) error {
4773         l := len(dAtA)
4774         iNdEx := 0
4775         for iNdEx < l {
4776                 preIndex := iNdEx
4777                 var wire uint64
4778                 for shift := uint(0); ; shift += 7 {
4779                         if shift >= 64 {
4780                                 return ErrIntOverflowGenerated
4781                         }
4782                         if iNdEx >= l {
4783                                 return io.ErrUnexpectedEOF
4784                         }
4785                         b := dAtA[iNdEx]
4786                         iNdEx++
4787                         wire |= (uint64(b) & 0x7F) << shift
4788                         if b < 0x80 {
4789                                 break
4790                         }
4791                 }
4792                 fieldNum := int32(wire >> 3)
4793                 wireType := int(wire & 0x7)
4794                 if wireType == 4 {
4795                         return fmt.Errorf("proto: CustomResourceSubresources: wiretype end group for non-group")
4796                 }
4797                 if fieldNum <= 0 {
4798                         return fmt.Errorf("proto: CustomResourceSubresources: illegal tag %d (wire type %d)", fieldNum, wire)
4799                 }
4800                 switch fieldNum {
4801                 case 1:
4802                         if wireType != 2 {
4803                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4804                         }
4805                         var msglen int
4806                         for shift := uint(0); ; shift += 7 {
4807                                 if shift >= 64 {
4808                                         return ErrIntOverflowGenerated
4809                                 }
4810                                 if iNdEx >= l {
4811                                         return io.ErrUnexpectedEOF
4812                                 }
4813                                 b := dAtA[iNdEx]
4814                                 iNdEx++
4815                                 msglen |= (int(b) & 0x7F) << shift
4816                                 if b < 0x80 {
4817                                         break
4818                                 }
4819                         }
4820                         if msglen < 0 {
4821                                 return ErrInvalidLengthGenerated
4822                         }
4823                         postIndex := iNdEx + msglen
4824                         if postIndex > l {
4825                                 return io.ErrUnexpectedEOF
4826                         }
4827                         if m.Status == nil {
4828                                 m.Status = &CustomResourceSubresourceStatus{}
4829                         }
4830                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4831                                 return err
4832                         }
4833                         iNdEx = postIndex
4834                 case 2:
4835                         if wireType != 2 {
4836                                 return fmt.Errorf("proto: wrong wireType = %d for field Scale", wireType)
4837                         }
4838                         var msglen int
4839                         for shift := uint(0); ; shift += 7 {
4840                                 if shift >= 64 {
4841                                         return ErrIntOverflowGenerated
4842                                 }
4843                                 if iNdEx >= l {
4844                                         return io.ErrUnexpectedEOF
4845                                 }
4846                                 b := dAtA[iNdEx]
4847                                 iNdEx++
4848                                 msglen |= (int(b) & 0x7F) << shift
4849                                 if b < 0x80 {
4850                                         break
4851                                 }
4852                         }
4853                         if msglen < 0 {
4854                                 return ErrInvalidLengthGenerated
4855                         }
4856                         postIndex := iNdEx + msglen
4857                         if postIndex > l {
4858                                 return io.ErrUnexpectedEOF
4859                         }
4860                         if m.Scale == nil {
4861                                 m.Scale = &CustomResourceSubresourceScale{}
4862                         }
4863                         if err := m.Scale.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4864                                 return err
4865                         }
4866                         iNdEx = postIndex
4867                 default:
4868                         iNdEx = preIndex
4869                         skippy, err := skipGenerated(dAtA[iNdEx:])
4870                         if err != nil {
4871                                 return err
4872                         }
4873                         if skippy < 0 {
4874                                 return ErrInvalidLengthGenerated
4875                         }
4876                         if (iNdEx + skippy) > l {
4877                                 return io.ErrUnexpectedEOF
4878                         }
4879                         iNdEx += skippy
4880                 }
4881         }
4882
4883         if iNdEx > l {
4884                 return io.ErrUnexpectedEOF
4885         }
4886         return nil
4887 }
4888 func (m *CustomResourceValidation) Unmarshal(dAtA []byte) error {
4889         l := len(dAtA)
4890         iNdEx := 0
4891         for iNdEx < l {
4892                 preIndex := iNdEx
4893                 var wire uint64
4894                 for shift := uint(0); ; shift += 7 {
4895                         if shift >= 64 {
4896                                 return ErrIntOverflowGenerated
4897                         }
4898                         if iNdEx >= l {
4899                                 return io.ErrUnexpectedEOF
4900                         }
4901                         b := dAtA[iNdEx]
4902                         iNdEx++
4903                         wire |= (uint64(b) & 0x7F) << shift
4904                         if b < 0x80 {
4905                                 break
4906                         }
4907                 }
4908                 fieldNum := int32(wire >> 3)
4909                 wireType := int(wire & 0x7)
4910                 if wireType == 4 {
4911                         return fmt.Errorf("proto: CustomResourceValidation: wiretype end group for non-group")
4912                 }
4913                 if fieldNum <= 0 {
4914                         return fmt.Errorf("proto: CustomResourceValidation: illegal tag %d (wire type %d)", fieldNum, wire)
4915                 }
4916                 switch fieldNum {
4917                 case 1:
4918                         if wireType != 2 {
4919                                 return fmt.Errorf("proto: wrong wireType = %d for field OpenAPIV3Schema", wireType)
4920                         }
4921                         var msglen int
4922                         for shift := uint(0); ; shift += 7 {
4923                                 if shift >= 64 {
4924                                         return ErrIntOverflowGenerated
4925                                 }
4926                                 if iNdEx >= l {
4927                                         return io.ErrUnexpectedEOF
4928                                 }
4929                                 b := dAtA[iNdEx]
4930                                 iNdEx++
4931                                 msglen |= (int(b) & 0x7F) << shift
4932                                 if b < 0x80 {
4933                                         break
4934                                 }
4935                         }
4936                         if msglen < 0 {
4937                                 return ErrInvalidLengthGenerated
4938                         }
4939                         postIndex := iNdEx + msglen
4940                         if postIndex > l {
4941                                 return io.ErrUnexpectedEOF
4942                         }
4943                         if m.OpenAPIV3Schema == nil {
4944                                 m.OpenAPIV3Schema = &JSONSchemaProps{}
4945                         }
4946                         if err := m.OpenAPIV3Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4947                                 return err
4948                         }
4949                         iNdEx = postIndex
4950                 default:
4951                         iNdEx = preIndex
4952                         skippy, err := skipGenerated(dAtA[iNdEx:])
4953                         if err != nil {
4954                                 return err
4955                         }
4956                         if skippy < 0 {
4957                                 return ErrInvalidLengthGenerated
4958                         }
4959                         if (iNdEx + skippy) > l {
4960                                 return io.ErrUnexpectedEOF
4961                         }
4962                         iNdEx += skippy
4963                 }
4964         }
4965
4966         if iNdEx > l {
4967                 return io.ErrUnexpectedEOF
4968         }
4969         return nil
4970 }
4971 func (m *ExternalDocumentation) Unmarshal(dAtA []byte) error {
4972         l := len(dAtA)
4973         iNdEx := 0
4974         for iNdEx < l {
4975                 preIndex := iNdEx
4976                 var wire uint64
4977                 for shift := uint(0); ; shift += 7 {
4978                         if shift >= 64 {
4979                                 return ErrIntOverflowGenerated
4980                         }
4981                         if iNdEx >= l {
4982                                 return io.ErrUnexpectedEOF
4983                         }
4984                         b := dAtA[iNdEx]
4985                         iNdEx++
4986                         wire |= (uint64(b) & 0x7F) << shift
4987                         if b < 0x80 {
4988                                 break
4989                         }
4990                 }
4991                 fieldNum := int32(wire >> 3)
4992                 wireType := int(wire & 0x7)
4993                 if wireType == 4 {
4994                         return fmt.Errorf("proto: ExternalDocumentation: wiretype end group for non-group")
4995                 }
4996                 if fieldNum <= 0 {
4997                         return fmt.Errorf("proto: ExternalDocumentation: illegal tag %d (wire type %d)", fieldNum, wire)
4998                 }
4999                 switch fieldNum {
5000                 case 1:
5001                         if wireType != 2 {
5002                                 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
5003                         }
5004                         var stringLen uint64
5005                         for shift := uint(0); ; shift += 7 {
5006                                 if shift >= 64 {
5007                                         return ErrIntOverflowGenerated
5008                                 }
5009                                 if iNdEx >= l {
5010                                         return io.ErrUnexpectedEOF
5011                                 }
5012                                 b := dAtA[iNdEx]
5013                                 iNdEx++
5014                                 stringLen |= (uint64(b) & 0x7F) << shift
5015                                 if b < 0x80 {
5016                                         break
5017                                 }
5018                         }
5019                         intStringLen := int(stringLen)
5020                         if intStringLen < 0 {
5021                                 return ErrInvalidLengthGenerated
5022                         }
5023                         postIndex := iNdEx + intStringLen
5024                         if postIndex > l {
5025                                 return io.ErrUnexpectedEOF
5026                         }
5027                         m.Description = string(dAtA[iNdEx:postIndex])
5028                         iNdEx = postIndex
5029                 case 2:
5030                         if wireType != 2 {
5031                                 return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
5032                         }
5033                         var stringLen uint64
5034                         for shift := uint(0); ; shift += 7 {
5035                                 if shift >= 64 {
5036                                         return ErrIntOverflowGenerated
5037                                 }
5038                                 if iNdEx >= l {
5039                                         return io.ErrUnexpectedEOF
5040                                 }
5041                                 b := dAtA[iNdEx]
5042                                 iNdEx++
5043                                 stringLen |= (uint64(b) & 0x7F) << shift
5044                                 if b < 0x80 {
5045                                         break
5046                                 }
5047                         }
5048                         intStringLen := int(stringLen)
5049                         if intStringLen < 0 {
5050                                 return ErrInvalidLengthGenerated
5051                         }
5052                         postIndex := iNdEx + intStringLen
5053                         if postIndex > l {
5054                                 return io.ErrUnexpectedEOF
5055                         }
5056                         m.URL = string(dAtA[iNdEx:postIndex])
5057                         iNdEx = postIndex
5058                 default:
5059                         iNdEx = preIndex
5060                         skippy, err := skipGenerated(dAtA[iNdEx:])
5061                         if err != nil {
5062                                 return err
5063                         }
5064                         if skippy < 0 {
5065                                 return ErrInvalidLengthGenerated
5066                         }
5067                         if (iNdEx + skippy) > l {
5068                                 return io.ErrUnexpectedEOF
5069                         }
5070                         iNdEx += skippy
5071                 }
5072         }
5073
5074         if iNdEx > l {
5075                 return io.ErrUnexpectedEOF
5076         }
5077         return nil
5078 }
5079 func (m *JSON) Unmarshal(dAtA []byte) error {
5080         l := len(dAtA)
5081         iNdEx := 0
5082         for iNdEx < l {
5083                 preIndex := iNdEx
5084                 var wire uint64
5085                 for shift := uint(0); ; shift += 7 {
5086                         if shift >= 64 {
5087                                 return ErrIntOverflowGenerated
5088                         }
5089                         if iNdEx >= l {
5090                                 return io.ErrUnexpectedEOF
5091                         }
5092                         b := dAtA[iNdEx]
5093                         iNdEx++
5094                         wire |= (uint64(b) & 0x7F) << shift
5095                         if b < 0x80 {
5096                                 break
5097                         }
5098                 }
5099                 fieldNum := int32(wire >> 3)
5100                 wireType := int(wire & 0x7)
5101                 if wireType == 4 {
5102                         return fmt.Errorf("proto: JSON: wiretype end group for non-group")
5103                 }
5104                 if fieldNum <= 0 {
5105                         return fmt.Errorf("proto: JSON: illegal tag %d (wire type %d)", fieldNum, wire)
5106                 }
5107                 switch fieldNum {
5108                 case 1:
5109                         if wireType != 2 {
5110                                 return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
5111                         }
5112                         var byteLen int
5113                         for shift := uint(0); ; shift += 7 {
5114                                 if shift >= 64 {
5115                                         return ErrIntOverflowGenerated
5116                                 }
5117                                 if iNdEx >= l {
5118                                         return io.ErrUnexpectedEOF
5119                                 }
5120                                 b := dAtA[iNdEx]
5121                                 iNdEx++
5122                                 byteLen |= (int(b) & 0x7F) << shift
5123                                 if b < 0x80 {
5124                                         break
5125                                 }
5126                         }
5127                         if byteLen < 0 {
5128                                 return ErrInvalidLengthGenerated
5129                         }
5130                         postIndex := iNdEx + byteLen
5131                         if postIndex > l {
5132                                 return io.ErrUnexpectedEOF
5133                         }
5134                         m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...)
5135                         if m.Raw == nil {
5136                                 m.Raw = []byte{}
5137                         }
5138                         iNdEx = postIndex
5139                 default:
5140                         iNdEx = preIndex
5141                         skippy, err := skipGenerated(dAtA[iNdEx:])
5142                         if err != nil {
5143                                 return err
5144                         }
5145                         if skippy < 0 {
5146                                 return ErrInvalidLengthGenerated
5147                         }
5148                         if (iNdEx + skippy) > l {
5149                                 return io.ErrUnexpectedEOF
5150                         }
5151                         iNdEx += skippy
5152                 }
5153         }
5154
5155         if iNdEx > l {
5156                 return io.ErrUnexpectedEOF
5157         }
5158         return nil
5159 }
5160 func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
5161         l := len(dAtA)
5162         iNdEx := 0
5163         for iNdEx < l {
5164                 preIndex := iNdEx
5165                 var wire uint64
5166                 for shift := uint(0); ; shift += 7 {
5167                         if shift >= 64 {
5168                                 return ErrIntOverflowGenerated
5169                         }
5170                         if iNdEx >= l {
5171                                 return io.ErrUnexpectedEOF
5172                         }
5173                         b := dAtA[iNdEx]
5174                         iNdEx++
5175                         wire |= (uint64(b) & 0x7F) << shift
5176                         if b < 0x80 {
5177                                 break
5178                         }
5179                 }
5180                 fieldNum := int32(wire >> 3)
5181                 wireType := int(wire & 0x7)
5182                 if wireType == 4 {
5183                         return fmt.Errorf("proto: JSONSchemaProps: wiretype end group for non-group")
5184                 }
5185                 if fieldNum <= 0 {
5186                         return fmt.Errorf("proto: JSONSchemaProps: illegal tag %d (wire type %d)", fieldNum, wire)
5187                 }
5188                 switch fieldNum {
5189                 case 1:
5190                         if wireType != 2 {
5191                                 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
5192                         }
5193                         var stringLen uint64
5194                         for shift := uint(0); ; shift += 7 {
5195                                 if shift >= 64 {
5196                                         return ErrIntOverflowGenerated
5197                                 }
5198                                 if iNdEx >= l {
5199                                         return io.ErrUnexpectedEOF
5200                                 }
5201                                 b := dAtA[iNdEx]
5202                                 iNdEx++
5203                                 stringLen |= (uint64(b) & 0x7F) << shift
5204                                 if b < 0x80 {
5205                                         break
5206                                 }
5207                         }
5208                         intStringLen := int(stringLen)
5209                         if intStringLen < 0 {
5210                                 return ErrInvalidLengthGenerated
5211                         }
5212                         postIndex := iNdEx + intStringLen
5213                         if postIndex > l {
5214                                 return io.ErrUnexpectedEOF
5215                         }
5216                         m.ID = string(dAtA[iNdEx:postIndex])
5217                         iNdEx = postIndex
5218                 case 2:
5219                         if wireType != 2 {
5220                                 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
5221                         }
5222                         var stringLen uint64
5223                         for shift := uint(0); ; shift += 7 {
5224                                 if shift >= 64 {
5225                                         return ErrIntOverflowGenerated
5226                                 }
5227                                 if iNdEx >= l {
5228                                         return io.ErrUnexpectedEOF
5229                                 }
5230                                 b := dAtA[iNdEx]
5231                                 iNdEx++
5232                                 stringLen |= (uint64(b) & 0x7F) << shift
5233                                 if b < 0x80 {
5234                                         break
5235                                 }
5236                         }
5237                         intStringLen := int(stringLen)
5238                         if intStringLen < 0 {
5239                                 return ErrInvalidLengthGenerated
5240                         }
5241                         postIndex := iNdEx + intStringLen
5242                         if postIndex > l {
5243                                 return io.ErrUnexpectedEOF
5244                         }
5245                         m.Schema = JSONSchemaURL(dAtA[iNdEx:postIndex])
5246                         iNdEx = postIndex
5247                 case 3:
5248                         if wireType != 2 {
5249                                 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
5250                         }
5251                         var stringLen uint64
5252                         for shift := uint(0); ; shift += 7 {
5253                                 if shift >= 64 {
5254                                         return ErrIntOverflowGenerated
5255                                 }
5256                                 if iNdEx >= l {
5257                                         return io.ErrUnexpectedEOF
5258                                 }
5259                                 b := dAtA[iNdEx]
5260                                 iNdEx++
5261                                 stringLen |= (uint64(b) & 0x7F) << shift
5262                                 if b < 0x80 {
5263                                         break
5264                                 }
5265                         }
5266                         intStringLen := int(stringLen)
5267                         if intStringLen < 0 {
5268                                 return ErrInvalidLengthGenerated
5269                         }
5270                         postIndex := iNdEx + intStringLen
5271                         if postIndex > l {
5272                                 return io.ErrUnexpectedEOF
5273                         }
5274                         s := string(dAtA[iNdEx:postIndex])
5275                         m.Ref = &s
5276                         iNdEx = postIndex
5277                 case 4:
5278                         if wireType != 2 {
5279                                 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
5280                         }
5281                         var stringLen uint64
5282                         for shift := uint(0); ; shift += 7 {
5283                                 if shift >= 64 {
5284                                         return ErrIntOverflowGenerated
5285                                 }
5286                                 if iNdEx >= l {
5287                                         return io.ErrUnexpectedEOF
5288                                 }
5289                                 b := dAtA[iNdEx]
5290                                 iNdEx++
5291                                 stringLen |= (uint64(b) & 0x7F) << shift
5292                                 if b < 0x80 {
5293                                         break
5294                                 }
5295                         }
5296                         intStringLen := int(stringLen)
5297                         if intStringLen < 0 {
5298                                 return ErrInvalidLengthGenerated
5299                         }
5300                         postIndex := iNdEx + intStringLen
5301                         if postIndex > l {
5302                                 return io.ErrUnexpectedEOF
5303                         }
5304                         m.Description = string(dAtA[iNdEx:postIndex])
5305                         iNdEx = postIndex
5306                 case 5:
5307                         if wireType != 2 {
5308                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5309                         }
5310                         var stringLen uint64
5311                         for shift := uint(0); ; shift += 7 {
5312                                 if shift >= 64 {
5313                                         return ErrIntOverflowGenerated
5314                                 }
5315                                 if iNdEx >= l {
5316                                         return io.ErrUnexpectedEOF
5317                                 }
5318                                 b := dAtA[iNdEx]
5319                                 iNdEx++
5320                                 stringLen |= (uint64(b) & 0x7F) << shift
5321                                 if b < 0x80 {
5322                                         break
5323                                 }
5324                         }
5325                         intStringLen := int(stringLen)
5326                         if intStringLen < 0 {
5327                                 return ErrInvalidLengthGenerated
5328                         }
5329                         postIndex := iNdEx + intStringLen
5330                         if postIndex > l {
5331                                 return io.ErrUnexpectedEOF
5332                         }
5333                         m.Type = string(dAtA[iNdEx:postIndex])
5334                         iNdEx = postIndex
5335                 case 6:
5336                         if wireType != 2 {
5337                                 return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
5338                         }
5339                         var stringLen uint64
5340                         for shift := uint(0); ; shift += 7 {
5341                                 if shift >= 64 {
5342                                         return ErrIntOverflowGenerated
5343                                 }
5344                                 if iNdEx >= l {
5345                                         return io.ErrUnexpectedEOF
5346                                 }
5347                                 b := dAtA[iNdEx]
5348                                 iNdEx++
5349                                 stringLen |= (uint64(b) & 0x7F) << shift
5350                                 if b < 0x80 {
5351                                         break
5352                                 }
5353                         }
5354                         intStringLen := int(stringLen)
5355                         if intStringLen < 0 {
5356                                 return ErrInvalidLengthGenerated
5357                         }
5358                         postIndex := iNdEx + intStringLen
5359                         if postIndex > l {
5360                                 return io.ErrUnexpectedEOF
5361                         }
5362                         m.Format = string(dAtA[iNdEx:postIndex])
5363                         iNdEx = postIndex
5364                 case 7:
5365                         if wireType != 2 {
5366                                 return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
5367                         }
5368                         var stringLen uint64
5369                         for shift := uint(0); ; shift += 7 {
5370                                 if shift >= 64 {
5371                                         return ErrIntOverflowGenerated
5372                                 }
5373                                 if iNdEx >= l {
5374                                         return io.ErrUnexpectedEOF
5375                                 }
5376                                 b := dAtA[iNdEx]
5377                                 iNdEx++
5378                                 stringLen |= (uint64(b) & 0x7F) << shift
5379                                 if b < 0x80 {
5380                                         break
5381                                 }
5382                         }
5383                         intStringLen := int(stringLen)
5384                         if intStringLen < 0 {
5385                                 return ErrInvalidLengthGenerated
5386                         }
5387                         postIndex := iNdEx + intStringLen
5388                         if postIndex > l {
5389                                 return io.ErrUnexpectedEOF
5390                         }
5391                         m.Title = string(dAtA[iNdEx:postIndex])
5392                         iNdEx = postIndex
5393                 case 8:
5394                         if wireType != 2 {
5395                                 return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
5396                         }
5397                         var msglen int
5398                         for shift := uint(0); ; shift += 7 {
5399                                 if shift >= 64 {
5400                                         return ErrIntOverflowGenerated
5401                                 }
5402                                 if iNdEx >= l {
5403                                         return io.ErrUnexpectedEOF
5404                                 }
5405                                 b := dAtA[iNdEx]
5406                                 iNdEx++
5407                                 msglen |= (int(b) & 0x7F) << shift
5408                                 if b < 0x80 {
5409                                         break
5410                                 }
5411                         }
5412                         if msglen < 0 {
5413                                 return ErrInvalidLengthGenerated
5414                         }
5415                         postIndex := iNdEx + msglen
5416                         if postIndex > l {
5417                                 return io.ErrUnexpectedEOF
5418                         }
5419                         if m.Default == nil {
5420                                 m.Default = &JSON{}
5421                         }
5422                         if err := m.Default.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5423                                 return err
5424                         }
5425                         iNdEx = postIndex
5426                 case 9:
5427                         if wireType != 1 {
5428                                 return fmt.Errorf("proto: wrong wireType = %d for field Maximum", wireType)
5429                         }
5430                         var v uint64
5431                         if (iNdEx + 8) > l {
5432                                 return io.ErrUnexpectedEOF
5433                         }
5434                         v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5435                         iNdEx += 8
5436                         v2 := float64(math.Float64frombits(v))
5437                         m.Maximum = &v2
5438                 case 10:
5439                         if wireType != 0 {
5440                                 return fmt.Errorf("proto: wrong wireType = %d for field ExclusiveMaximum", wireType)
5441                         }
5442                         var v int
5443                         for shift := uint(0); ; shift += 7 {
5444                                 if shift >= 64 {
5445                                         return ErrIntOverflowGenerated
5446                                 }
5447                                 if iNdEx >= l {
5448                                         return io.ErrUnexpectedEOF
5449                                 }
5450                                 b := dAtA[iNdEx]
5451                                 iNdEx++
5452                                 v |= (int(b) & 0x7F) << shift
5453                                 if b < 0x80 {
5454                                         break
5455                                 }
5456                         }
5457                         m.ExclusiveMaximum = bool(v != 0)
5458                 case 11:
5459                         if wireType != 1 {
5460                                 return fmt.Errorf("proto: wrong wireType = %d for field Minimum", wireType)
5461                         }
5462                         var v uint64
5463                         if (iNdEx + 8) > l {
5464                                 return io.ErrUnexpectedEOF
5465                         }
5466                         v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5467                         iNdEx += 8
5468                         v2 := float64(math.Float64frombits(v))
5469                         m.Minimum = &v2
5470                 case 12:
5471                         if wireType != 0 {
5472                                 return fmt.Errorf("proto: wrong wireType = %d for field ExclusiveMinimum", wireType)
5473                         }
5474                         var v int
5475                         for shift := uint(0); ; shift += 7 {
5476                                 if shift >= 64 {
5477                                         return ErrIntOverflowGenerated
5478                                 }
5479                                 if iNdEx >= l {
5480                                         return io.ErrUnexpectedEOF
5481                                 }
5482                                 b := dAtA[iNdEx]
5483                                 iNdEx++
5484                                 v |= (int(b) & 0x7F) << shift
5485                                 if b < 0x80 {
5486                                         break
5487                                 }
5488                         }
5489                         m.ExclusiveMinimum = bool(v != 0)
5490                 case 13:
5491                         if wireType != 0 {
5492                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxLength", wireType)
5493                         }
5494                         var v int64
5495                         for shift := uint(0); ; shift += 7 {
5496                                 if shift >= 64 {
5497                                         return ErrIntOverflowGenerated
5498                                 }
5499                                 if iNdEx >= l {
5500                                         return io.ErrUnexpectedEOF
5501                                 }
5502                                 b := dAtA[iNdEx]
5503                                 iNdEx++
5504                                 v |= (int64(b) & 0x7F) << shift
5505                                 if b < 0x80 {
5506                                         break
5507                                 }
5508                         }
5509                         m.MaxLength = &v
5510                 case 14:
5511                         if wireType != 0 {
5512                                 return fmt.Errorf("proto: wrong wireType = %d for field MinLength", wireType)
5513                         }
5514                         var v int64
5515                         for shift := uint(0); ; shift += 7 {
5516                                 if shift >= 64 {
5517                                         return ErrIntOverflowGenerated
5518                                 }
5519                                 if iNdEx >= l {
5520                                         return io.ErrUnexpectedEOF
5521                                 }
5522                                 b := dAtA[iNdEx]
5523                                 iNdEx++
5524                                 v |= (int64(b) & 0x7F) << shift
5525                                 if b < 0x80 {
5526                                         break
5527                                 }
5528                         }
5529                         m.MinLength = &v
5530                 case 15:
5531                         if wireType != 2 {
5532                                 return fmt.Errorf("proto: wrong wireType = %d for field Pattern", wireType)
5533                         }
5534                         var stringLen uint64
5535                         for shift := uint(0); ; shift += 7 {
5536                                 if shift >= 64 {
5537                                         return ErrIntOverflowGenerated
5538                                 }
5539                                 if iNdEx >= l {
5540                                         return io.ErrUnexpectedEOF
5541                                 }
5542                                 b := dAtA[iNdEx]
5543                                 iNdEx++
5544                                 stringLen |= (uint64(b) & 0x7F) << shift
5545                                 if b < 0x80 {
5546                                         break
5547                                 }
5548                         }
5549                         intStringLen := int(stringLen)
5550                         if intStringLen < 0 {
5551                                 return ErrInvalidLengthGenerated
5552                         }
5553                         postIndex := iNdEx + intStringLen
5554                         if postIndex > l {
5555                                 return io.ErrUnexpectedEOF
5556                         }
5557                         m.Pattern = string(dAtA[iNdEx:postIndex])
5558                         iNdEx = postIndex
5559                 case 16:
5560                         if wireType != 0 {
5561                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxItems", wireType)
5562                         }
5563                         var v int64
5564                         for shift := uint(0); ; shift += 7 {
5565                                 if shift >= 64 {
5566                                         return ErrIntOverflowGenerated
5567                                 }
5568                                 if iNdEx >= l {
5569                                         return io.ErrUnexpectedEOF
5570                                 }
5571                                 b := dAtA[iNdEx]
5572                                 iNdEx++
5573                                 v |= (int64(b) & 0x7F) << shift
5574                                 if b < 0x80 {
5575                                         break
5576                                 }
5577                         }
5578                         m.MaxItems = &v
5579                 case 17:
5580                         if wireType != 0 {
5581                                 return fmt.Errorf("proto: wrong wireType = %d for field MinItems", wireType)
5582                         }
5583                         var v int64
5584                         for shift := uint(0); ; shift += 7 {
5585                                 if shift >= 64 {
5586                                         return ErrIntOverflowGenerated
5587                                 }
5588                                 if iNdEx >= l {
5589                                         return io.ErrUnexpectedEOF
5590                                 }
5591                                 b := dAtA[iNdEx]
5592                                 iNdEx++
5593                                 v |= (int64(b) & 0x7F) << shift
5594                                 if b < 0x80 {
5595                                         break
5596                                 }
5597                         }
5598                         m.MinItems = &v
5599                 case 18:
5600                         if wireType != 0 {
5601                                 return fmt.Errorf("proto: wrong wireType = %d for field UniqueItems", wireType)
5602                         }
5603                         var v int
5604                         for shift := uint(0); ; shift += 7 {
5605                                 if shift >= 64 {
5606                                         return ErrIntOverflowGenerated
5607                                 }
5608                                 if iNdEx >= l {
5609                                         return io.ErrUnexpectedEOF
5610                                 }
5611                                 b := dAtA[iNdEx]
5612                                 iNdEx++
5613                                 v |= (int(b) & 0x7F) << shift
5614                                 if b < 0x80 {
5615                                         break
5616                                 }
5617                         }
5618                         m.UniqueItems = bool(v != 0)
5619                 case 19:
5620                         if wireType != 1 {
5621                                 return fmt.Errorf("proto: wrong wireType = %d for field MultipleOf", wireType)
5622                         }
5623                         var v uint64
5624                         if (iNdEx + 8) > l {
5625                                 return io.ErrUnexpectedEOF
5626                         }
5627                         v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5628                         iNdEx += 8
5629                         v2 := float64(math.Float64frombits(v))
5630                         m.MultipleOf = &v2
5631                 case 20:
5632                         if wireType != 2 {
5633                                 return fmt.Errorf("proto: wrong wireType = %d for field Enum", wireType)
5634                         }
5635                         var msglen int
5636                         for shift := uint(0); ; shift += 7 {
5637                                 if shift >= 64 {
5638                                         return ErrIntOverflowGenerated
5639                                 }
5640                                 if iNdEx >= l {
5641                                         return io.ErrUnexpectedEOF
5642                                 }
5643                                 b := dAtA[iNdEx]
5644                                 iNdEx++
5645                                 msglen |= (int(b) & 0x7F) << shift
5646                                 if b < 0x80 {
5647                                         break
5648                                 }
5649                         }
5650                         if msglen < 0 {
5651                                 return ErrInvalidLengthGenerated
5652                         }
5653                         postIndex := iNdEx + msglen
5654                         if postIndex > l {
5655                                 return io.ErrUnexpectedEOF
5656                         }
5657                         m.Enum = append(m.Enum, JSON{})
5658                         if err := m.Enum[len(m.Enum)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5659                                 return err
5660                         }
5661                         iNdEx = postIndex
5662                 case 21:
5663                         if wireType != 0 {
5664                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxProperties", wireType)
5665                         }
5666                         var v int64
5667                         for shift := uint(0); ; shift += 7 {
5668                                 if shift >= 64 {
5669                                         return ErrIntOverflowGenerated
5670                                 }
5671                                 if iNdEx >= l {
5672                                         return io.ErrUnexpectedEOF
5673                                 }
5674                                 b := dAtA[iNdEx]
5675                                 iNdEx++
5676                                 v |= (int64(b) & 0x7F) << shift
5677                                 if b < 0x80 {
5678                                         break
5679                                 }
5680                         }
5681                         m.MaxProperties = &v
5682                 case 22:
5683                         if wireType != 0 {
5684                                 return fmt.Errorf("proto: wrong wireType = %d for field MinProperties", wireType)
5685                         }
5686                         var v int64
5687                         for shift := uint(0); ; shift += 7 {
5688                                 if shift >= 64 {
5689                                         return ErrIntOverflowGenerated
5690                                 }
5691                                 if iNdEx >= l {
5692                                         return io.ErrUnexpectedEOF
5693                                 }
5694                                 b := dAtA[iNdEx]
5695                                 iNdEx++
5696                                 v |= (int64(b) & 0x7F) << shift
5697                                 if b < 0x80 {
5698                                         break
5699                                 }
5700                         }
5701                         m.MinProperties = &v
5702                 case 23:
5703                         if wireType != 2 {
5704                                 return fmt.Errorf("proto: wrong wireType = %d for field Required", wireType)
5705                         }
5706                         var stringLen uint64
5707                         for shift := uint(0); ; shift += 7 {
5708                                 if shift >= 64 {
5709                                         return ErrIntOverflowGenerated
5710                                 }
5711                                 if iNdEx >= l {
5712                                         return io.ErrUnexpectedEOF
5713                                 }
5714                                 b := dAtA[iNdEx]
5715                                 iNdEx++
5716                                 stringLen |= (uint64(b) & 0x7F) << shift
5717                                 if b < 0x80 {
5718                                         break
5719                                 }
5720                         }
5721                         intStringLen := int(stringLen)
5722                         if intStringLen < 0 {
5723                                 return ErrInvalidLengthGenerated
5724                         }
5725                         postIndex := iNdEx + intStringLen
5726                         if postIndex > l {
5727                                 return io.ErrUnexpectedEOF
5728                         }
5729                         m.Required = append(m.Required, string(dAtA[iNdEx:postIndex]))
5730                         iNdEx = postIndex
5731                 case 24:
5732                         if wireType != 2 {
5733                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5734                         }
5735                         var msglen int
5736                         for shift := uint(0); ; shift += 7 {
5737                                 if shift >= 64 {
5738                                         return ErrIntOverflowGenerated
5739                                 }
5740                                 if iNdEx >= l {
5741                                         return io.ErrUnexpectedEOF
5742                                 }
5743                                 b := dAtA[iNdEx]
5744                                 iNdEx++
5745                                 msglen |= (int(b) & 0x7F) << shift
5746                                 if b < 0x80 {
5747                                         break
5748                                 }
5749                         }
5750                         if msglen < 0 {
5751                                 return ErrInvalidLengthGenerated
5752                         }
5753                         postIndex := iNdEx + msglen
5754                         if postIndex > l {
5755                                 return io.ErrUnexpectedEOF
5756                         }
5757                         if m.Items == nil {
5758                                 m.Items = &JSONSchemaPropsOrArray{}
5759                         }
5760                         if err := m.Items.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5761                                 return err
5762                         }
5763                         iNdEx = postIndex
5764                 case 25:
5765                         if wireType != 2 {
5766                                 return fmt.Errorf("proto: wrong wireType = %d for field AllOf", wireType)
5767                         }
5768                         var msglen int
5769                         for shift := uint(0); ; shift += 7 {
5770                                 if shift >= 64 {
5771                                         return ErrIntOverflowGenerated
5772                                 }
5773                                 if iNdEx >= l {
5774                                         return io.ErrUnexpectedEOF
5775                                 }
5776                                 b := dAtA[iNdEx]
5777                                 iNdEx++
5778                                 msglen |= (int(b) & 0x7F) << shift
5779                                 if b < 0x80 {
5780                                         break
5781                                 }
5782                         }
5783                         if msglen < 0 {
5784                                 return ErrInvalidLengthGenerated
5785                         }
5786                         postIndex := iNdEx + msglen
5787                         if postIndex > l {
5788                                 return io.ErrUnexpectedEOF
5789                         }
5790                         m.AllOf = append(m.AllOf, JSONSchemaProps{})
5791                         if err := m.AllOf[len(m.AllOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5792                                 return err
5793                         }
5794                         iNdEx = postIndex
5795                 case 26:
5796                         if wireType != 2 {
5797                                 return fmt.Errorf("proto: wrong wireType = %d for field OneOf", wireType)
5798                         }
5799                         var msglen int
5800                         for shift := uint(0); ; shift += 7 {
5801                                 if shift >= 64 {
5802                                         return ErrIntOverflowGenerated
5803                                 }
5804                                 if iNdEx >= l {
5805                                         return io.ErrUnexpectedEOF
5806                                 }
5807                                 b := dAtA[iNdEx]
5808                                 iNdEx++
5809                                 msglen |= (int(b) & 0x7F) << shift
5810                                 if b < 0x80 {
5811                                         break
5812                                 }
5813                         }
5814                         if msglen < 0 {
5815                                 return ErrInvalidLengthGenerated
5816                         }
5817                         postIndex := iNdEx + msglen
5818                         if postIndex > l {
5819                                 return io.ErrUnexpectedEOF
5820                         }
5821                         m.OneOf = append(m.OneOf, JSONSchemaProps{})
5822                         if err := m.OneOf[len(m.OneOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5823                                 return err
5824                         }
5825                         iNdEx = postIndex
5826                 case 27:
5827                         if wireType != 2 {
5828                                 return fmt.Errorf("proto: wrong wireType = %d for field AnyOf", wireType)
5829                         }
5830                         var msglen int
5831                         for shift := uint(0); ; shift += 7 {
5832                                 if shift >= 64 {
5833                                         return ErrIntOverflowGenerated
5834                                 }
5835                                 if iNdEx >= l {
5836                                         return io.ErrUnexpectedEOF
5837                                 }
5838                                 b := dAtA[iNdEx]
5839                                 iNdEx++
5840                                 msglen |= (int(b) & 0x7F) << shift
5841                                 if b < 0x80 {
5842                                         break
5843                                 }
5844                         }
5845                         if msglen < 0 {
5846                                 return ErrInvalidLengthGenerated
5847                         }
5848                         postIndex := iNdEx + msglen
5849                         if postIndex > l {
5850                                 return io.ErrUnexpectedEOF
5851                         }
5852                         m.AnyOf = append(m.AnyOf, JSONSchemaProps{})
5853                         if err := m.AnyOf[len(m.AnyOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5854                                 return err
5855                         }
5856                         iNdEx = postIndex
5857                 case 28:
5858                         if wireType != 2 {
5859                                 return fmt.Errorf("proto: wrong wireType = %d for field Not", wireType)
5860                         }
5861                         var msglen int
5862                         for shift := uint(0); ; shift += 7 {
5863                                 if shift >= 64 {
5864                                         return ErrIntOverflowGenerated
5865                                 }
5866                                 if iNdEx >= l {
5867                                         return io.ErrUnexpectedEOF
5868                                 }
5869                                 b := dAtA[iNdEx]
5870                                 iNdEx++
5871                                 msglen |= (int(b) & 0x7F) << shift
5872                                 if b < 0x80 {
5873                                         break
5874                                 }
5875                         }
5876                         if msglen < 0 {
5877                                 return ErrInvalidLengthGenerated
5878                         }
5879                         postIndex := iNdEx + msglen
5880                         if postIndex > l {
5881                                 return io.ErrUnexpectedEOF
5882                         }
5883                         if m.Not == nil {
5884                                 m.Not = &JSONSchemaProps{}
5885                         }
5886                         if err := m.Not.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5887                                 return err
5888                         }
5889                         iNdEx = postIndex
5890                 case 29:
5891                         if wireType != 2 {
5892                                 return fmt.Errorf("proto: wrong wireType = %d for field Properties", wireType)
5893                         }
5894                         var msglen int
5895                         for shift := uint(0); ; shift += 7 {
5896                                 if shift >= 64 {
5897                                         return ErrIntOverflowGenerated
5898                                 }
5899                                 if iNdEx >= l {
5900                                         return io.ErrUnexpectedEOF
5901                                 }
5902                                 b := dAtA[iNdEx]
5903                                 iNdEx++
5904                                 msglen |= (int(b) & 0x7F) << shift
5905                                 if b < 0x80 {
5906                                         break
5907                                 }
5908                         }
5909                         if msglen < 0 {
5910                                 return ErrInvalidLengthGenerated
5911                         }
5912                         postIndex := iNdEx + msglen
5913                         if postIndex > l {
5914                                 return io.ErrUnexpectedEOF
5915                         }
5916                         if m.Properties == nil {
5917                                 m.Properties = make(map[string]JSONSchemaProps)
5918                         }
5919                         var mapkey string
5920                         mapvalue := &JSONSchemaProps{}
5921                         for iNdEx < postIndex {
5922                                 entryPreIndex := iNdEx
5923                                 var wire uint64
5924                                 for shift := uint(0); ; shift += 7 {
5925                                         if shift >= 64 {
5926                                                 return ErrIntOverflowGenerated
5927                                         }
5928                                         if iNdEx >= l {
5929                                                 return io.ErrUnexpectedEOF
5930                                         }
5931                                         b := dAtA[iNdEx]
5932                                         iNdEx++
5933                                         wire |= (uint64(b) & 0x7F) << shift
5934                                         if b < 0x80 {
5935                                                 break
5936                                         }
5937                                 }
5938                                 fieldNum := int32(wire >> 3)
5939                                 if fieldNum == 1 {
5940                                         var stringLenmapkey uint64
5941                                         for shift := uint(0); ; shift += 7 {
5942                                                 if shift >= 64 {
5943                                                         return ErrIntOverflowGenerated
5944                                                 }
5945                                                 if iNdEx >= l {
5946                                                         return io.ErrUnexpectedEOF
5947                                                 }
5948                                                 b := dAtA[iNdEx]
5949                                                 iNdEx++
5950                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
5951                                                 if b < 0x80 {
5952                                                         break
5953                                                 }
5954                                         }
5955                                         intStringLenmapkey := int(stringLenmapkey)
5956                                         if intStringLenmapkey < 0 {
5957                                                 return ErrInvalidLengthGenerated
5958                                         }
5959                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
5960                                         if postStringIndexmapkey > l {
5961                                                 return io.ErrUnexpectedEOF
5962                                         }
5963                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5964                                         iNdEx = postStringIndexmapkey
5965                                 } else if fieldNum == 2 {
5966                                         var mapmsglen int
5967                                         for shift := uint(0); ; shift += 7 {
5968                                                 if shift >= 64 {
5969                                                         return ErrIntOverflowGenerated
5970                                                 }
5971                                                 if iNdEx >= l {
5972                                                         return io.ErrUnexpectedEOF
5973                                                 }
5974                                                 b := dAtA[iNdEx]
5975                                                 iNdEx++
5976                                                 mapmsglen |= (int(b) & 0x7F) << shift
5977                                                 if b < 0x80 {
5978                                                         break
5979                                                 }
5980                                         }
5981                                         if mapmsglen < 0 {
5982                                                 return ErrInvalidLengthGenerated
5983                                         }
5984                                         postmsgIndex := iNdEx + mapmsglen
5985                                         if mapmsglen < 0 {
5986                                                 return ErrInvalidLengthGenerated
5987                                         }
5988                                         if postmsgIndex > l {
5989                                                 return io.ErrUnexpectedEOF
5990                                         }
5991                                         mapvalue = &JSONSchemaProps{}
5992                                         if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
5993                                                 return err
5994                                         }
5995                                         iNdEx = postmsgIndex
5996                                 } else {
5997                                         iNdEx = entryPreIndex
5998                                         skippy, err := skipGenerated(dAtA[iNdEx:])
5999                                         if err != nil {
6000                                                 return err
6001                                         }
6002                                         if skippy < 0 {
6003                                                 return ErrInvalidLengthGenerated
6004                                         }
6005                                         if (iNdEx + skippy) > postIndex {
6006                                                 return io.ErrUnexpectedEOF
6007                                         }
6008                                         iNdEx += skippy
6009                                 }
6010                         }
6011                         m.Properties[mapkey] = *mapvalue
6012                         iNdEx = postIndex
6013                 case 30:
6014                         if wireType != 2 {
6015                                 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalProperties", wireType)
6016                         }
6017                         var msglen int
6018                         for shift := uint(0); ; shift += 7 {
6019                                 if shift >= 64 {
6020                                         return ErrIntOverflowGenerated
6021                                 }
6022                                 if iNdEx >= l {
6023                                         return io.ErrUnexpectedEOF
6024                                 }
6025                                 b := dAtA[iNdEx]
6026                                 iNdEx++
6027                                 msglen |= (int(b) & 0x7F) << shift
6028                                 if b < 0x80 {
6029                                         break
6030                                 }
6031                         }
6032                         if msglen < 0 {
6033                                 return ErrInvalidLengthGenerated
6034                         }
6035                         postIndex := iNdEx + msglen
6036                         if postIndex > l {
6037                                 return io.ErrUnexpectedEOF
6038                         }
6039                         if m.AdditionalProperties == nil {
6040                                 m.AdditionalProperties = &JSONSchemaPropsOrBool{}
6041                         }
6042                         if err := m.AdditionalProperties.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6043                                 return err
6044                         }
6045                         iNdEx = postIndex
6046                 case 31:
6047                         if wireType != 2 {
6048                                 return fmt.Errorf("proto: wrong wireType = %d for field PatternProperties", wireType)
6049                         }
6050                         var msglen int
6051                         for shift := uint(0); ; shift += 7 {
6052                                 if shift >= 64 {
6053                                         return ErrIntOverflowGenerated
6054                                 }
6055                                 if iNdEx >= l {
6056                                         return io.ErrUnexpectedEOF
6057                                 }
6058                                 b := dAtA[iNdEx]
6059                                 iNdEx++
6060                                 msglen |= (int(b) & 0x7F) << shift
6061                                 if b < 0x80 {
6062                                         break
6063                                 }
6064                         }
6065                         if msglen < 0 {
6066                                 return ErrInvalidLengthGenerated
6067                         }
6068                         postIndex := iNdEx + msglen
6069                         if postIndex > l {
6070                                 return io.ErrUnexpectedEOF
6071                         }
6072                         if m.PatternProperties == nil {
6073                                 m.PatternProperties = make(map[string]JSONSchemaProps)
6074                         }
6075                         var mapkey string
6076                         mapvalue := &JSONSchemaProps{}
6077                         for iNdEx < postIndex {
6078                                 entryPreIndex := iNdEx
6079                                 var wire uint64
6080                                 for shift := uint(0); ; shift += 7 {
6081                                         if shift >= 64 {
6082                                                 return ErrIntOverflowGenerated
6083                                         }
6084                                         if iNdEx >= l {
6085                                                 return io.ErrUnexpectedEOF
6086                                         }
6087                                         b := dAtA[iNdEx]
6088                                         iNdEx++
6089                                         wire |= (uint64(b) & 0x7F) << shift
6090                                         if b < 0x80 {
6091                                                 break
6092                                         }
6093                                 }
6094                                 fieldNum := int32(wire >> 3)
6095                                 if fieldNum == 1 {
6096                                         var stringLenmapkey uint64
6097                                         for shift := uint(0); ; shift += 7 {
6098                                                 if shift >= 64 {
6099                                                         return ErrIntOverflowGenerated
6100                                                 }
6101                                                 if iNdEx >= l {
6102                                                         return io.ErrUnexpectedEOF
6103                                                 }
6104                                                 b := dAtA[iNdEx]
6105                                                 iNdEx++
6106                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6107                                                 if b < 0x80 {
6108                                                         break
6109                                                 }
6110                                         }
6111                                         intStringLenmapkey := int(stringLenmapkey)
6112                                         if intStringLenmapkey < 0 {
6113                                                 return ErrInvalidLengthGenerated
6114                                         }
6115                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
6116                                         if postStringIndexmapkey > l {
6117                                                 return io.ErrUnexpectedEOF
6118                                         }
6119                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6120                                         iNdEx = postStringIndexmapkey
6121                                 } else if fieldNum == 2 {
6122                                         var mapmsglen int
6123                                         for shift := uint(0); ; shift += 7 {
6124                                                 if shift >= 64 {
6125                                                         return ErrIntOverflowGenerated
6126                                                 }
6127                                                 if iNdEx >= l {
6128                                                         return io.ErrUnexpectedEOF
6129                                                 }
6130                                                 b := dAtA[iNdEx]
6131                                                 iNdEx++
6132                                                 mapmsglen |= (int(b) & 0x7F) << shift
6133                                                 if b < 0x80 {
6134                                                         break
6135                                                 }
6136                                         }
6137                                         if mapmsglen < 0 {
6138                                                 return ErrInvalidLengthGenerated
6139                                         }
6140                                         postmsgIndex := iNdEx + mapmsglen
6141                                         if mapmsglen < 0 {
6142                                                 return ErrInvalidLengthGenerated
6143                                         }
6144                                         if postmsgIndex > l {
6145                                                 return io.ErrUnexpectedEOF
6146                                         }
6147                                         mapvalue = &JSONSchemaProps{}
6148                                         if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
6149                                                 return err
6150                                         }
6151                                         iNdEx = postmsgIndex
6152                                 } else {
6153                                         iNdEx = entryPreIndex
6154                                         skippy, err := skipGenerated(dAtA[iNdEx:])
6155                                         if err != nil {
6156                                                 return err
6157                                         }
6158                                         if skippy < 0 {
6159                                                 return ErrInvalidLengthGenerated
6160                                         }
6161                                         if (iNdEx + skippy) > postIndex {
6162                                                 return io.ErrUnexpectedEOF
6163                                         }
6164                                         iNdEx += skippy
6165                                 }
6166                         }
6167                         m.PatternProperties[mapkey] = *mapvalue
6168                         iNdEx = postIndex
6169                 case 32:
6170                         if wireType != 2 {
6171                                 return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
6172                         }
6173                         var msglen int
6174                         for shift := uint(0); ; shift += 7 {
6175                                 if shift >= 64 {
6176                                         return ErrIntOverflowGenerated
6177                                 }
6178                                 if iNdEx >= l {
6179                                         return io.ErrUnexpectedEOF
6180                                 }
6181                                 b := dAtA[iNdEx]
6182                                 iNdEx++
6183                                 msglen |= (int(b) & 0x7F) << shift
6184                                 if b < 0x80 {
6185                                         break
6186                                 }
6187                         }
6188                         if msglen < 0 {
6189                                 return ErrInvalidLengthGenerated
6190                         }
6191                         postIndex := iNdEx + msglen
6192                         if postIndex > l {
6193                                 return io.ErrUnexpectedEOF
6194                         }
6195                         if m.Dependencies == nil {
6196                                 m.Dependencies = make(JSONSchemaDependencies)
6197                         }
6198                         var mapkey string
6199                         mapvalue := &JSONSchemaPropsOrStringArray{}
6200                         for iNdEx < postIndex {
6201                                 entryPreIndex := iNdEx
6202                                 var wire uint64
6203                                 for shift := uint(0); ; shift += 7 {
6204                                         if shift >= 64 {
6205                                                 return ErrIntOverflowGenerated
6206                                         }
6207                                         if iNdEx >= l {
6208                                                 return io.ErrUnexpectedEOF
6209                                         }
6210                                         b := dAtA[iNdEx]
6211                                         iNdEx++
6212                                         wire |= (uint64(b) & 0x7F) << shift
6213                                         if b < 0x80 {
6214                                                 break
6215                                         }
6216                                 }
6217                                 fieldNum := int32(wire >> 3)
6218                                 if fieldNum == 1 {
6219                                         var stringLenmapkey uint64
6220                                         for shift := uint(0); ; shift += 7 {
6221                                                 if shift >= 64 {
6222                                                         return ErrIntOverflowGenerated
6223                                                 }
6224                                                 if iNdEx >= l {
6225                                                         return io.ErrUnexpectedEOF
6226                                                 }
6227                                                 b := dAtA[iNdEx]
6228                                                 iNdEx++
6229                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6230                                                 if b < 0x80 {
6231                                                         break
6232                                                 }
6233                                         }
6234                                         intStringLenmapkey := int(stringLenmapkey)
6235                                         if intStringLenmapkey < 0 {
6236                                                 return ErrInvalidLengthGenerated
6237                                         }
6238                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
6239                                         if postStringIndexmapkey > l {
6240                                                 return io.ErrUnexpectedEOF
6241                                         }
6242                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6243                                         iNdEx = postStringIndexmapkey
6244                                 } else if fieldNum == 2 {
6245                                         var mapmsglen int
6246                                         for shift := uint(0); ; shift += 7 {
6247                                                 if shift >= 64 {
6248                                                         return ErrIntOverflowGenerated
6249                                                 }
6250                                                 if iNdEx >= l {
6251                                                         return io.ErrUnexpectedEOF
6252                                                 }
6253                                                 b := dAtA[iNdEx]
6254                                                 iNdEx++
6255                                                 mapmsglen |= (int(b) & 0x7F) << shift
6256                                                 if b < 0x80 {
6257                                                         break
6258                                                 }
6259                                         }
6260                                         if mapmsglen < 0 {
6261                                                 return ErrInvalidLengthGenerated
6262                                         }
6263                                         postmsgIndex := iNdEx + mapmsglen
6264                                         if mapmsglen < 0 {
6265                                                 return ErrInvalidLengthGenerated
6266                                         }
6267                                         if postmsgIndex > l {
6268                                                 return io.ErrUnexpectedEOF
6269                                         }
6270                                         mapvalue = &JSONSchemaPropsOrStringArray{}
6271                                         if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
6272                                                 return err
6273                                         }
6274                                         iNdEx = postmsgIndex
6275                                 } else {
6276                                         iNdEx = entryPreIndex
6277                                         skippy, err := skipGenerated(dAtA[iNdEx:])
6278                                         if err != nil {
6279                                                 return err
6280                                         }
6281                                         if skippy < 0 {
6282                                                 return ErrInvalidLengthGenerated
6283                                         }
6284                                         if (iNdEx + skippy) > postIndex {
6285                                                 return io.ErrUnexpectedEOF
6286                                         }
6287                                         iNdEx += skippy
6288                                 }
6289                         }
6290                         m.Dependencies[mapkey] = *mapvalue
6291                         iNdEx = postIndex
6292                 case 33:
6293                         if wireType != 2 {
6294                                 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalItems", wireType)
6295                         }
6296                         var msglen int
6297                         for shift := uint(0); ; shift += 7 {
6298                                 if shift >= 64 {
6299                                         return ErrIntOverflowGenerated
6300                                 }
6301                                 if iNdEx >= l {
6302                                         return io.ErrUnexpectedEOF
6303                                 }
6304                                 b := dAtA[iNdEx]
6305                                 iNdEx++
6306                                 msglen |= (int(b) & 0x7F) << shift
6307                                 if b < 0x80 {
6308                                         break
6309                                 }
6310                         }
6311                         if msglen < 0 {
6312                                 return ErrInvalidLengthGenerated
6313                         }
6314                         postIndex := iNdEx + msglen
6315                         if postIndex > l {
6316                                 return io.ErrUnexpectedEOF
6317                         }
6318                         if m.AdditionalItems == nil {
6319                                 m.AdditionalItems = &JSONSchemaPropsOrBool{}
6320                         }
6321                         if err := m.AdditionalItems.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6322                                 return err
6323                         }
6324                         iNdEx = postIndex
6325                 case 34:
6326                         if wireType != 2 {
6327                                 return fmt.Errorf("proto: wrong wireType = %d for field Definitions", wireType)
6328                         }
6329                         var msglen int
6330                         for shift := uint(0); ; shift += 7 {
6331                                 if shift >= 64 {
6332                                         return ErrIntOverflowGenerated
6333                                 }
6334                                 if iNdEx >= l {
6335                                         return io.ErrUnexpectedEOF
6336                                 }
6337                                 b := dAtA[iNdEx]
6338                                 iNdEx++
6339                                 msglen |= (int(b) & 0x7F) << shift
6340                                 if b < 0x80 {
6341                                         break
6342                                 }
6343                         }
6344                         if msglen < 0 {
6345                                 return ErrInvalidLengthGenerated
6346                         }
6347                         postIndex := iNdEx + msglen
6348                         if postIndex > l {
6349                                 return io.ErrUnexpectedEOF
6350                         }
6351                         if m.Definitions == nil {
6352                                 m.Definitions = make(JSONSchemaDefinitions)
6353                         }
6354                         var mapkey string
6355                         mapvalue := &JSONSchemaProps{}
6356                         for iNdEx < postIndex {
6357                                 entryPreIndex := iNdEx
6358                                 var wire uint64
6359                                 for shift := uint(0); ; shift += 7 {
6360                                         if shift >= 64 {
6361                                                 return ErrIntOverflowGenerated
6362                                         }
6363                                         if iNdEx >= l {
6364                                                 return io.ErrUnexpectedEOF
6365                                         }
6366                                         b := dAtA[iNdEx]
6367                                         iNdEx++
6368                                         wire |= (uint64(b) & 0x7F) << shift
6369                                         if b < 0x80 {
6370                                                 break
6371                                         }
6372                                 }
6373                                 fieldNum := int32(wire >> 3)
6374                                 if fieldNum == 1 {
6375                                         var stringLenmapkey uint64
6376                                         for shift := uint(0); ; shift += 7 {
6377                                                 if shift >= 64 {
6378                                                         return ErrIntOverflowGenerated
6379                                                 }
6380                                                 if iNdEx >= l {
6381                                                         return io.ErrUnexpectedEOF
6382                                                 }
6383                                                 b := dAtA[iNdEx]
6384                                                 iNdEx++
6385                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6386                                                 if b < 0x80 {
6387                                                         break
6388                                                 }
6389                                         }
6390                                         intStringLenmapkey := int(stringLenmapkey)
6391                                         if intStringLenmapkey < 0 {
6392                                                 return ErrInvalidLengthGenerated
6393                                         }
6394                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
6395                                         if postStringIndexmapkey > l {
6396                                                 return io.ErrUnexpectedEOF
6397                                         }
6398                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6399                                         iNdEx = postStringIndexmapkey
6400                                 } else if fieldNum == 2 {
6401                                         var mapmsglen int
6402                                         for shift := uint(0); ; shift += 7 {
6403                                                 if shift >= 64 {
6404                                                         return ErrIntOverflowGenerated
6405                                                 }
6406                                                 if iNdEx >= l {
6407                                                         return io.ErrUnexpectedEOF
6408                                                 }
6409                                                 b := dAtA[iNdEx]
6410                                                 iNdEx++
6411                                                 mapmsglen |= (int(b) & 0x7F) << shift
6412                                                 if b < 0x80 {
6413                                                         break
6414                                                 }
6415                                         }
6416                                         if mapmsglen < 0 {
6417                                                 return ErrInvalidLengthGenerated
6418                                         }
6419                                         postmsgIndex := iNdEx + mapmsglen
6420                                         if mapmsglen < 0 {
6421                                                 return ErrInvalidLengthGenerated
6422                                         }
6423                                         if postmsgIndex > l {
6424                                                 return io.ErrUnexpectedEOF
6425                                         }
6426                                         mapvalue = &JSONSchemaProps{}
6427                                         if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
6428                                                 return err
6429                                         }
6430                                         iNdEx = postmsgIndex
6431                                 } else {
6432                                         iNdEx = entryPreIndex
6433                                         skippy, err := skipGenerated(dAtA[iNdEx:])
6434                                         if err != nil {
6435                                                 return err
6436                                         }
6437                                         if skippy < 0 {
6438                                                 return ErrInvalidLengthGenerated
6439                                         }
6440                                         if (iNdEx + skippy) > postIndex {
6441                                                 return io.ErrUnexpectedEOF
6442                                         }
6443                                         iNdEx += skippy
6444                                 }
6445                         }
6446                         m.Definitions[mapkey] = *mapvalue
6447                         iNdEx = postIndex
6448                 case 35:
6449                         if wireType != 2 {
6450                                 return fmt.Errorf("proto: wrong wireType = %d for field ExternalDocs", wireType)
6451                         }
6452                         var msglen int
6453                         for shift := uint(0); ; shift += 7 {
6454                                 if shift >= 64 {
6455                                         return ErrIntOverflowGenerated
6456                                 }
6457                                 if iNdEx >= l {
6458                                         return io.ErrUnexpectedEOF
6459                                 }
6460                                 b := dAtA[iNdEx]
6461                                 iNdEx++
6462                                 msglen |= (int(b) & 0x7F) << shift
6463                                 if b < 0x80 {
6464                                         break
6465                                 }
6466                         }
6467                         if msglen < 0 {
6468                                 return ErrInvalidLengthGenerated
6469                         }
6470                         postIndex := iNdEx + msglen
6471                         if postIndex > l {
6472                                 return io.ErrUnexpectedEOF
6473                         }
6474                         if m.ExternalDocs == nil {
6475                                 m.ExternalDocs = &ExternalDocumentation{}
6476                         }
6477                         if err := m.ExternalDocs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6478                                 return err
6479                         }
6480                         iNdEx = postIndex
6481                 case 36:
6482                         if wireType != 2 {
6483                                 return fmt.Errorf("proto: wrong wireType = %d for field Example", wireType)
6484                         }
6485                         var msglen int
6486                         for shift := uint(0); ; shift += 7 {
6487                                 if shift >= 64 {
6488                                         return ErrIntOverflowGenerated
6489                                 }
6490                                 if iNdEx >= l {
6491                                         return io.ErrUnexpectedEOF
6492                                 }
6493                                 b := dAtA[iNdEx]
6494                                 iNdEx++
6495                                 msglen |= (int(b) & 0x7F) << shift
6496                                 if b < 0x80 {
6497                                         break
6498                                 }
6499                         }
6500                         if msglen < 0 {
6501                                 return ErrInvalidLengthGenerated
6502                         }
6503                         postIndex := iNdEx + msglen
6504                         if postIndex > l {
6505                                 return io.ErrUnexpectedEOF
6506                         }
6507                         if m.Example == nil {
6508                                 m.Example = &JSON{}
6509                         }
6510                         if err := m.Example.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6511                                 return err
6512                         }
6513                         iNdEx = postIndex
6514                 default:
6515                         iNdEx = preIndex
6516                         skippy, err := skipGenerated(dAtA[iNdEx:])
6517                         if err != nil {
6518                                 return err
6519                         }
6520                         if skippy < 0 {
6521                                 return ErrInvalidLengthGenerated
6522                         }
6523                         if (iNdEx + skippy) > l {
6524                                 return io.ErrUnexpectedEOF
6525                         }
6526                         iNdEx += skippy
6527                 }
6528         }
6529
6530         if iNdEx > l {
6531                 return io.ErrUnexpectedEOF
6532         }
6533         return nil
6534 }
6535 func (m *JSONSchemaPropsOrArray) Unmarshal(dAtA []byte) error {
6536         l := len(dAtA)
6537         iNdEx := 0
6538         for iNdEx < l {
6539                 preIndex := iNdEx
6540                 var wire uint64
6541                 for shift := uint(0); ; shift += 7 {
6542                         if shift >= 64 {
6543                                 return ErrIntOverflowGenerated
6544                         }
6545                         if iNdEx >= l {
6546                                 return io.ErrUnexpectedEOF
6547                         }
6548                         b := dAtA[iNdEx]
6549                         iNdEx++
6550                         wire |= (uint64(b) & 0x7F) << shift
6551                         if b < 0x80 {
6552                                 break
6553                         }
6554                 }
6555                 fieldNum := int32(wire >> 3)
6556                 wireType := int(wire & 0x7)
6557                 if wireType == 4 {
6558                         return fmt.Errorf("proto: JSONSchemaPropsOrArray: wiretype end group for non-group")
6559                 }
6560                 if fieldNum <= 0 {
6561                         return fmt.Errorf("proto: JSONSchemaPropsOrArray: illegal tag %d (wire type %d)", fieldNum, wire)
6562                 }
6563                 switch fieldNum {
6564                 case 1:
6565                         if wireType != 2 {
6566                                 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
6567                         }
6568                         var msglen int
6569                         for shift := uint(0); ; shift += 7 {
6570                                 if shift >= 64 {
6571                                         return ErrIntOverflowGenerated
6572                                 }
6573                                 if iNdEx >= l {
6574                                         return io.ErrUnexpectedEOF
6575                                 }
6576                                 b := dAtA[iNdEx]
6577                                 iNdEx++
6578                                 msglen |= (int(b) & 0x7F) << shift
6579                                 if b < 0x80 {
6580                                         break
6581                                 }
6582                         }
6583                         if msglen < 0 {
6584                                 return ErrInvalidLengthGenerated
6585                         }
6586                         postIndex := iNdEx + msglen
6587                         if postIndex > l {
6588                                 return io.ErrUnexpectedEOF
6589                         }
6590                         if m.Schema == nil {
6591                                 m.Schema = &JSONSchemaProps{}
6592                         }
6593                         if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6594                                 return err
6595                         }
6596                         iNdEx = postIndex
6597                 case 2:
6598                         if wireType != 2 {
6599                                 return fmt.Errorf("proto: wrong wireType = %d for field JSONSchemas", wireType)
6600                         }
6601                         var msglen int
6602                         for shift := uint(0); ; shift += 7 {
6603                                 if shift >= 64 {
6604                                         return ErrIntOverflowGenerated
6605                                 }
6606                                 if iNdEx >= l {
6607                                         return io.ErrUnexpectedEOF
6608                                 }
6609                                 b := dAtA[iNdEx]
6610                                 iNdEx++
6611                                 msglen |= (int(b) & 0x7F) << shift
6612                                 if b < 0x80 {
6613                                         break
6614                                 }
6615                         }
6616                         if msglen < 0 {
6617                                 return ErrInvalidLengthGenerated
6618                         }
6619                         postIndex := iNdEx + msglen
6620                         if postIndex > l {
6621                                 return io.ErrUnexpectedEOF
6622                         }
6623                         m.JSONSchemas = append(m.JSONSchemas, JSONSchemaProps{})
6624                         if err := m.JSONSchemas[len(m.JSONSchemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6625                                 return err
6626                         }
6627                         iNdEx = postIndex
6628                 default:
6629                         iNdEx = preIndex
6630                         skippy, err := skipGenerated(dAtA[iNdEx:])
6631                         if err != nil {
6632                                 return err
6633                         }
6634                         if skippy < 0 {
6635                                 return ErrInvalidLengthGenerated
6636                         }
6637                         if (iNdEx + skippy) > l {
6638                                 return io.ErrUnexpectedEOF
6639                         }
6640                         iNdEx += skippy
6641                 }
6642         }
6643
6644         if iNdEx > l {
6645                 return io.ErrUnexpectedEOF
6646         }
6647         return nil
6648 }
6649 func (m *JSONSchemaPropsOrBool) Unmarshal(dAtA []byte) error {
6650         l := len(dAtA)
6651         iNdEx := 0
6652         for iNdEx < l {
6653                 preIndex := iNdEx
6654                 var wire uint64
6655                 for shift := uint(0); ; shift += 7 {
6656                         if shift >= 64 {
6657                                 return ErrIntOverflowGenerated
6658                         }
6659                         if iNdEx >= l {
6660                                 return io.ErrUnexpectedEOF
6661                         }
6662                         b := dAtA[iNdEx]
6663                         iNdEx++
6664                         wire |= (uint64(b) & 0x7F) << shift
6665                         if b < 0x80 {
6666                                 break
6667                         }
6668                 }
6669                 fieldNum := int32(wire >> 3)
6670                 wireType := int(wire & 0x7)
6671                 if wireType == 4 {
6672                         return fmt.Errorf("proto: JSONSchemaPropsOrBool: wiretype end group for non-group")
6673                 }
6674                 if fieldNum <= 0 {
6675                         return fmt.Errorf("proto: JSONSchemaPropsOrBool: illegal tag %d (wire type %d)", fieldNum, wire)
6676                 }
6677                 switch fieldNum {
6678                 case 1:
6679                         if wireType != 0 {
6680                                 return fmt.Errorf("proto: wrong wireType = %d for field Allows", wireType)
6681                         }
6682                         var v int
6683                         for shift := uint(0); ; shift += 7 {
6684                                 if shift >= 64 {
6685                                         return ErrIntOverflowGenerated
6686                                 }
6687                                 if iNdEx >= l {
6688                                         return io.ErrUnexpectedEOF
6689                                 }
6690                                 b := dAtA[iNdEx]
6691                                 iNdEx++
6692                                 v |= (int(b) & 0x7F) << shift
6693                                 if b < 0x80 {
6694                                         break
6695                                 }
6696                         }
6697                         m.Allows = bool(v != 0)
6698                 case 2:
6699                         if wireType != 2 {
6700                                 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
6701                         }
6702                         var msglen int
6703                         for shift := uint(0); ; shift += 7 {
6704                                 if shift >= 64 {
6705                                         return ErrIntOverflowGenerated
6706                                 }
6707                                 if iNdEx >= l {
6708                                         return io.ErrUnexpectedEOF
6709                                 }
6710                                 b := dAtA[iNdEx]
6711                                 iNdEx++
6712                                 msglen |= (int(b) & 0x7F) << shift
6713                                 if b < 0x80 {
6714                                         break
6715                                 }
6716                         }
6717                         if msglen < 0 {
6718                                 return ErrInvalidLengthGenerated
6719                         }
6720                         postIndex := iNdEx + msglen
6721                         if postIndex > l {
6722                                 return io.ErrUnexpectedEOF
6723                         }
6724                         if m.Schema == nil {
6725                                 m.Schema = &JSONSchemaProps{}
6726                         }
6727                         if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6728                                 return err
6729                         }
6730                         iNdEx = postIndex
6731                 default:
6732                         iNdEx = preIndex
6733                         skippy, err := skipGenerated(dAtA[iNdEx:])
6734                         if err != nil {
6735                                 return err
6736                         }
6737                         if skippy < 0 {
6738                                 return ErrInvalidLengthGenerated
6739                         }
6740                         if (iNdEx + skippy) > l {
6741                                 return io.ErrUnexpectedEOF
6742                         }
6743                         iNdEx += skippy
6744                 }
6745         }
6746
6747         if iNdEx > l {
6748                 return io.ErrUnexpectedEOF
6749         }
6750         return nil
6751 }
6752 func (m *JSONSchemaPropsOrStringArray) Unmarshal(dAtA []byte) error {
6753         l := len(dAtA)
6754         iNdEx := 0
6755         for iNdEx < l {
6756                 preIndex := iNdEx
6757                 var wire uint64
6758                 for shift := uint(0); ; shift += 7 {
6759                         if shift >= 64 {
6760                                 return ErrIntOverflowGenerated
6761                         }
6762                         if iNdEx >= l {
6763                                 return io.ErrUnexpectedEOF
6764                         }
6765                         b := dAtA[iNdEx]
6766                         iNdEx++
6767                         wire |= (uint64(b) & 0x7F) << shift
6768                         if b < 0x80 {
6769                                 break
6770                         }
6771                 }
6772                 fieldNum := int32(wire >> 3)
6773                 wireType := int(wire & 0x7)
6774                 if wireType == 4 {
6775                         return fmt.Errorf("proto: JSONSchemaPropsOrStringArray: wiretype end group for non-group")
6776                 }
6777                 if fieldNum <= 0 {
6778                         return fmt.Errorf("proto: JSONSchemaPropsOrStringArray: illegal tag %d (wire type %d)", fieldNum, wire)
6779                 }
6780                 switch fieldNum {
6781                 case 1:
6782                         if wireType != 2 {
6783                                 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
6784                         }
6785                         var msglen int
6786                         for shift := uint(0); ; shift += 7 {
6787                                 if shift >= 64 {
6788                                         return ErrIntOverflowGenerated
6789                                 }
6790                                 if iNdEx >= l {
6791                                         return io.ErrUnexpectedEOF
6792                                 }
6793                                 b := dAtA[iNdEx]
6794                                 iNdEx++
6795                                 msglen |= (int(b) & 0x7F) << shift
6796                                 if b < 0x80 {
6797                                         break
6798                                 }
6799                         }
6800                         if msglen < 0 {
6801                                 return ErrInvalidLengthGenerated
6802                         }
6803                         postIndex := iNdEx + msglen
6804                         if postIndex > l {
6805                                 return io.ErrUnexpectedEOF
6806                         }
6807                         if m.Schema == nil {
6808                                 m.Schema = &JSONSchemaProps{}
6809                         }
6810                         if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6811                                 return err
6812                         }
6813                         iNdEx = postIndex
6814                 case 2:
6815                         if wireType != 2 {
6816                                 return fmt.Errorf("proto: wrong wireType = %d for field Property", wireType)
6817                         }
6818                         var stringLen uint64
6819                         for shift := uint(0); ; shift += 7 {
6820                                 if shift >= 64 {
6821                                         return ErrIntOverflowGenerated
6822                                 }
6823                                 if iNdEx >= l {
6824                                         return io.ErrUnexpectedEOF
6825                                 }
6826                                 b := dAtA[iNdEx]
6827                                 iNdEx++
6828                                 stringLen |= (uint64(b) & 0x7F) << shift
6829                                 if b < 0x80 {
6830                                         break
6831                                 }
6832                         }
6833                         intStringLen := int(stringLen)
6834                         if intStringLen < 0 {
6835                                 return ErrInvalidLengthGenerated
6836                         }
6837                         postIndex := iNdEx + intStringLen
6838                         if postIndex > l {
6839                                 return io.ErrUnexpectedEOF
6840                         }
6841                         m.Property = append(m.Property, string(dAtA[iNdEx:postIndex]))
6842                         iNdEx = postIndex
6843                 default:
6844                         iNdEx = preIndex
6845                         skippy, err := skipGenerated(dAtA[iNdEx:])
6846                         if err != nil {
6847                                 return err
6848                         }
6849                         if skippy < 0 {
6850                                 return ErrInvalidLengthGenerated
6851                         }
6852                         if (iNdEx + skippy) > l {
6853                                 return io.ErrUnexpectedEOF
6854                         }
6855                         iNdEx += skippy
6856                 }
6857         }
6858
6859         if iNdEx > l {
6860                 return io.ErrUnexpectedEOF
6861         }
6862         return nil
6863 }
6864 func (m *ServiceReference) Unmarshal(dAtA []byte) error {
6865         l := len(dAtA)
6866         iNdEx := 0
6867         for iNdEx < l {
6868                 preIndex := iNdEx
6869                 var wire uint64
6870                 for shift := uint(0); ; shift += 7 {
6871                         if shift >= 64 {
6872                                 return ErrIntOverflowGenerated
6873                         }
6874                         if iNdEx >= l {
6875                                 return io.ErrUnexpectedEOF
6876                         }
6877                         b := dAtA[iNdEx]
6878                         iNdEx++
6879                         wire |= (uint64(b) & 0x7F) << shift
6880                         if b < 0x80 {
6881                                 break
6882                         }
6883                 }
6884                 fieldNum := int32(wire >> 3)
6885                 wireType := int(wire & 0x7)
6886                 if wireType == 4 {
6887                         return fmt.Errorf("proto: ServiceReference: wiretype end group for non-group")
6888                 }
6889                 if fieldNum <= 0 {
6890                         return fmt.Errorf("proto: ServiceReference: illegal tag %d (wire type %d)", fieldNum, wire)
6891                 }
6892                 switch fieldNum {
6893                 case 1:
6894                         if wireType != 2 {
6895                                 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
6896                         }
6897                         var stringLen uint64
6898                         for shift := uint(0); ; shift += 7 {
6899                                 if shift >= 64 {
6900                                         return ErrIntOverflowGenerated
6901                                 }
6902                                 if iNdEx >= l {
6903                                         return io.ErrUnexpectedEOF
6904                                 }
6905                                 b := dAtA[iNdEx]
6906                                 iNdEx++
6907                                 stringLen |= (uint64(b) & 0x7F) << shift
6908                                 if b < 0x80 {
6909                                         break
6910                                 }
6911                         }
6912                         intStringLen := int(stringLen)
6913                         if intStringLen < 0 {
6914                                 return ErrInvalidLengthGenerated
6915                         }
6916                         postIndex := iNdEx + intStringLen
6917                         if postIndex > l {
6918                                 return io.ErrUnexpectedEOF
6919                         }
6920                         m.Namespace = string(dAtA[iNdEx:postIndex])
6921                         iNdEx = postIndex
6922                 case 2:
6923                         if wireType != 2 {
6924                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6925                         }
6926                         var stringLen uint64
6927                         for shift := uint(0); ; shift += 7 {
6928                                 if shift >= 64 {
6929                                         return ErrIntOverflowGenerated
6930                                 }
6931                                 if iNdEx >= l {
6932                                         return io.ErrUnexpectedEOF
6933                                 }
6934                                 b := dAtA[iNdEx]
6935                                 iNdEx++
6936                                 stringLen |= (uint64(b) & 0x7F) << shift
6937                                 if b < 0x80 {
6938                                         break
6939                                 }
6940                         }
6941                         intStringLen := int(stringLen)
6942                         if intStringLen < 0 {
6943                                 return ErrInvalidLengthGenerated
6944                         }
6945                         postIndex := iNdEx + intStringLen
6946                         if postIndex > l {
6947                                 return io.ErrUnexpectedEOF
6948                         }
6949                         m.Name = string(dAtA[iNdEx:postIndex])
6950                         iNdEx = postIndex
6951                 case 3:
6952                         if wireType != 2 {
6953                                 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
6954                         }
6955                         var stringLen uint64
6956                         for shift := uint(0); ; shift += 7 {
6957                                 if shift >= 64 {
6958                                         return ErrIntOverflowGenerated
6959                                 }
6960                                 if iNdEx >= l {
6961                                         return io.ErrUnexpectedEOF
6962                                 }
6963                                 b := dAtA[iNdEx]
6964                                 iNdEx++
6965                                 stringLen |= (uint64(b) & 0x7F) << shift
6966                                 if b < 0x80 {
6967                                         break
6968                                 }
6969                         }
6970                         intStringLen := int(stringLen)
6971                         if intStringLen < 0 {
6972                                 return ErrInvalidLengthGenerated
6973                         }
6974                         postIndex := iNdEx + intStringLen
6975                         if postIndex > l {
6976                                 return io.ErrUnexpectedEOF
6977                         }
6978                         s := string(dAtA[iNdEx:postIndex])
6979                         m.Path = &s
6980                         iNdEx = postIndex
6981                 default:
6982                         iNdEx = preIndex
6983                         skippy, err := skipGenerated(dAtA[iNdEx:])
6984                         if err != nil {
6985                                 return err
6986                         }
6987                         if skippy < 0 {
6988                                 return ErrInvalidLengthGenerated
6989                         }
6990                         if (iNdEx + skippy) > l {
6991                                 return io.ErrUnexpectedEOF
6992                         }
6993                         iNdEx += skippy
6994                 }
6995         }
6996
6997         if iNdEx > l {
6998                 return io.ErrUnexpectedEOF
6999         }
7000         return nil
7001 }
7002 func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error {
7003         l := len(dAtA)
7004         iNdEx := 0
7005         for iNdEx < l {
7006                 preIndex := iNdEx
7007                 var wire uint64
7008                 for shift := uint(0); ; shift += 7 {
7009                         if shift >= 64 {
7010                                 return ErrIntOverflowGenerated
7011                         }
7012                         if iNdEx >= l {
7013                                 return io.ErrUnexpectedEOF
7014                         }
7015                         b := dAtA[iNdEx]
7016                         iNdEx++
7017                         wire |= (uint64(b) & 0x7F) << shift
7018                         if b < 0x80 {
7019                                 break
7020                         }
7021                 }
7022                 fieldNum := int32(wire >> 3)
7023                 wireType := int(wire & 0x7)
7024                 if wireType == 4 {
7025                         return fmt.Errorf("proto: WebhookClientConfig: wiretype end group for non-group")
7026                 }
7027                 if fieldNum <= 0 {
7028                         return fmt.Errorf("proto: WebhookClientConfig: illegal tag %d (wire type %d)", fieldNum, wire)
7029                 }
7030                 switch fieldNum {
7031                 case 1:
7032                         if wireType != 2 {
7033                                 return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
7034                         }
7035                         var msglen int
7036                         for shift := uint(0); ; shift += 7 {
7037                                 if shift >= 64 {
7038                                         return ErrIntOverflowGenerated
7039                                 }
7040                                 if iNdEx >= l {
7041                                         return io.ErrUnexpectedEOF
7042                                 }
7043                                 b := dAtA[iNdEx]
7044                                 iNdEx++
7045                                 msglen |= (int(b) & 0x7F) << shift
7046                                 if b < 0x80 {
7047                                         break
7048                                 }
7049                         }
7050                         if msglen < 0 {
7051                                 return ErrInvalidLengthGenerated
7052                         }
7053                         postIndex := iNdEx + msglen
7054                         if postIndex > l {
7055                                 return io.ErrUnexpectedEOF
7056                         }
7057                         if m.Service == nil {
7058                                 m.Service = &ServiceReference{}
7059                         }
7060                         if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7061                                 return err
7062                         }
7063                         iNdEx = postIndex
7064                 case 2:
7065                         if wireType != 2 {
7066                                 return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
7067                         }
7068                         var byteLen int
7069                         for shift := uint(0); ; shift += 7 {
7070                                 if shift >= 64 {
7071                                         return ErrIntOverflowGenerated
7072                                 }
7073                                 if iNdEx >= l {
7074                                         return io.ErrUnexpectedEOF
7075                                 }
7076                                 b := dAtA[iNdEx]
7077                                 iNdEx++
7078                                 byteLen |= (int(b) & 0x7F) << shift
7079                                 if b < 0x80 {
7080                                         break
7081                                 }
7082                         }
7083                         if byteLen < 0 {
7084                                 return ErrInvalidLengthGenerated
7085                         }
7086                         postIndex := iNdEx + byteLen
7087                         if postIndex > l {
7088                                 return io.ErrUnexpectedEOF
7089                         }
7090                         m.CABundle = append(m.CABundle[:0], dAtA[iNdEx:postIndex]...)
7091                         if m.CABundle == nil {
7092                                 m.CABundle = []byte{}
7093                         }
7094                         iNdEx = postIndex
7095                 case 3:
7096                         if wireType != 2 {
7097                                 return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
7098                         }
7099                         var stringLen uint64
7100                         for shift := uint(0); ; shift += 7 {
7101                                 if shift >= 64 {
7102                                         return ErrIntOverflowGenerated
7103                                 }
7104                                 if iNdEx >= l {
7105                                         return io.ErrUnexpectedEOF
7106                                 }
7107                                 b := dAtA[iNdEx]
7108                                 iNdEx++
7109                                 stringLen |= (uint64(b) & 0x7F) << shift
7110                                 if b < 0x80 {
7111                                         break
7112                                 }
7113                         }
7114                         intStringLen := int(stringLen)
7115                         if intStringLen < 0 {
7116                                 return ErrInvalidLengthGenerated
7117                         }
7118                         postIndex := iNdEx + intStringLen
7119                         if postIndex > l {
7120                                 return io.ErrUnexpectedEOF
7121                         }
7122                         s := string(dAtA[iNdEx:postIndex])
7123                         m.URL = &s
7124                         iNdEx = postIndex
7125                 default:
7126                         iNdEx = preIndex
7127                         skippy, err := skipGenerated(dAtA[iNdEx:])
7128                         if err != nil {
7129                                 return err
7130                         }
7131                         if skippy < 0 {
7132                                 return ErrInvalidLengthGenerated
7133                         }
7134                         if (iNdEx + skippy) > l {
7135                                 return io.ErrUnexpectedEOF
7136                         }
7137                         iNdEx += skippy
7138                 }
7139         }
7140
7141         if iNdEx > l {
7142                 return io.ErrUnexpectedEOF
7143         }
7144         return nil
7145 }
7146 func skipGenerated(dAtA []byte) (n int, err error) {
7147         l := len(dAtA)
7148         iNdEx := 0
7149         for iNdEx < l {
7150                 var wire uint64
7151                 for shift := uint(0); ; shift += 7 {
7152                         if shift >= 64 {
7153                                 return 0, ErrIntOverflowGenerated
7154                         }
7155                         if iNdEx >= l {
7156                                 return 0, io.ErrUnexpectedEOF
7157                         }
7158                         b := dAtA[iNdEx]
7159                         iNdEx++
7160                         wire |= (uint64(b) & 0x7F) << shift
7161                         if b < 0x80 {
7162                                 break
7163                         }
7164                 }
7165                 wireType := int(wire & 0x7)
7166                 switch wireType {
7167                 case 0:
7168                         for shift := uint(0); ; shift += 7 {
7169                                 if shift >= 64 {
7170                                         return 0, ErrIntOverflowGenerated
7171                                 }
7172                                 if iNdEx >= l {
7173                                         return 0, io.ErrUnexpectedEOF
7174                                 }
7175                                 iNdEx++
7176                                 if dAtA[iNdEx-1] < 0x80 {
7177                                         break
7178                                 }
7179                         }
7180                         return iNdEx, nil
7181                 case 1:
7182                         iNdEx += 8
7183                         return iNdEx, nil
7184                 case 2:
7185                         var length int
7186                         for shift := uint(0); ; shift += 7 {
7187                                 if shift >= 64 {
7188                                         return 0, ErrIntOverflowGenerated
7189                                 }
7190                                 if iNdEx >= l {
7191                                         return 0, io.ErrUnexpectedEOF
7192                                 }
7193                                 b := dAtA[iNdEx]
7194                                 iNdEx++
7195                                 length |= (int(b) & 0x7F) << shift
7196                                 if b < 0x80 {
7197                                         break
7198                                 }
7199                         }
7200                         iNdEx += length
7201                         if length < 0 {
7202                                 return 0, ErrInvalidLengthGenerated
7203                         }
7204                         return iNdEx, nil
7205                 case 3:
7206                         for {
7207                                 var innerWire uint64
7208                                 var start int = iNdEx
7209                                 for shift := uint(0); ; shift += 7 {
7210                                         if shift >= 64 {
7211                                                 return 0, ErrIntOverflowGenerated
7212                                         }
7213                                         if iNdEx >= l {
7214                                                 return 0, io.ErrUnexpectedEOF
7215                                         }
7216                                         b := dAtA[iNdEx]
7217                                         iNdEx++
7218                                         innerWire |= (uint64(b) & 0x7F) << shift
7219                                         if b < 0x80 {
7220                                                 break
7221                                         }
7222                                 }
7223                                 innerWireType := int(innerWire & 0x7)
7224                                 if innerWireType == 4 {
7225                                         break
7226                                 }
7227                                 next, err := skipGenerated(dAtA[start:])
7228                                 if err != nil {
7229                                         return 0, err
7230                                 }
7231                                 iNdEx = start + next
7232                         }
7233                         return iNdEx, nil
7234                 case 4:
7235                         return iNdEx, nil
7236                 case 5:
7237                         iNdEx += 4
7238                         return iNdEx, nil
7239                 default:
7240                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
7241                 }
7242         }
7243         panic("unreachable")
7244 }
7245
7246 var (
7247         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
7248         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
7249 )
7250
7251 func init() {
7252         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto", fileDescriptorGenerated)
7253 }
7254
7255 var fileDescriptorGenerated = []byte{
7256         // 2740 bytes of a gzipped FileDescriptorProto
7257         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0x1c, 0x47,
7258         0x15, 0xf7, 0xec, 0x6a, 0xa5, 0x55, 0x4b, 0xb2, 0xa4, 0xb6, 0xe5, 0x8c, 0x85, 0xbd, 0x2b, 0xad,
7259         0x49, 0x4a, 0x04, 0x7b, 0x15, 0x9b, 0x84, 0x84, 0x54, 0x71, 0xd0, 0x4a, 0x4a, 0x4a, 0xc6, 0xfa,
7260         0xa0, 0xd7, 0x76, 0x80, 0x7c, 0xb6, 0x66, 0x7b, 0x57, 0x63, 0xcd, 0x97, 0xa7, 0x67, 0x56, 0x52,
7261         0x05, 0x28, 0x48, 0x2a, 0x05, 0x45, 0x01, 0xa1, 0x88, 0x2f, 0x14, 0x70, 0x00, 0x8a, 0x0b, 0x45,
7262         0xc1, 0x01, 0x6e, 0xf0, 0x07, 0xf8, 0x98, 0xe2, 0x94, 0xd3, 0x16, 0xde, 0xfc, 0x0b, 0x54, 0x51,
7263         0xa5, 0x13, 0xd5, 0x1f, 0xd3, 0x33, 0x3b, 0xbb, 0x6b, 0xab, 0xe2, 0xdd, 0x98, 0x9b, 0xe6, 0xbd,
7264         0xd7, 0xef, 0xf7, 0xfa, 0xf5, 0x7b, 0xaf, 0x5f, 0xbf, 0x15, 0xa8, 0xef, 0xbf, 0x44, 0xcb, 0xa6,
7265         0xbb, 0xbc, 0x1f, 0xee, 0x12, 0xdf, 0x21, 0x01, 0xa1, 0xcb, 0x4d, 0xe2, 0xd4, 0x5c, 0x7f, 0x59,
7266         0x32, 0xb0, 0x67, 0x92, 0xc3, 0x80, 0x38, 0xd4, 0x74, 0x1d, 0x7a, 0x05, 0x7b, 0x26, 0x25, 0x7e,
7267         0x93, 0xf8, 0xcb, 0xde, 0x7e, 0x83, 0xf1, 0x68, 0xa7, 0xc0, 0x72, 0xf3, 0xea, 0x2e, 0x09, 0xf0,
7268         0xd5, 0xe5, 0x06, 0x71, 0x88, 0x8f, 0x03, 0x52, 0x2b, 0x7b, 0xbe, 0x1b, 0xb8, 0xf0, 0xeb, 0x42,
7269         0x5d, 0xb9, 0x43, 0xfa, 0x6d, 0xa5, 0xae, 0xec, 0xed, 0x37, 0x18, 0x8f, 0x76, 0x0a, 0x94, 0xa5,
7270         0xba, 0xf9, 0x2b, 0x0d, 0x33, 0xd8, 0x0b, 0x77, 0xcb, 0x86, 0x6b, 0x2f, 0x37, 0xdc, 0x86, 0xbb,
7271         0xcc, 0xb5, 0xee, 0x86, 0x75, 0xfe, 0xc5, 0x3f, 0xf8, 0x5f, 0x02, 0x6d, 0xfe, 0xf9, 0xd8, 0x78,
7272         0x1b, 0x1b, 0x7b, 0xa6, 0x43, 0xfc, 0xa3, 0xd8, 0x62, 0x9b, 0x04, 0x78, 0xb9, 0xd9, 0x65, 0xe3,
7273         0xfc, 0x72, 0xbf, 0x55, 0x7e, 0xe8, 0x04, 0xa6, 0x4d, 0xba, 0x16, 0x7c, 0xf5, 0x51, 0x0b, 0xa8,
7274         0xb1, 0x47, 0x6c, 0x9c, 0x5e, 0x57, 0x3a, 0xd6, 0xc0, 0xec, 0xaa, 0xeb, 0x34, 0x89, 0xcf, 0x76,
7275         0x89, 0xc8, 0xdd, 0x90, 0xd0, 0x00, 0x56, 0x40, 0x36, 0x34, 0x6b, 0xba, 0xb6, 0xa0, 0x2d, 0x8d,
7276         0x57, 0x9e, 0xbb, 0xdf, 0x2a, 0x9e, 0x6a, 0xb7, 0x8a, 0xd9, 0x5b, 0x1b, 0x6b, 0xc7, 0xad, 0xe2,
7277         0x62, 0x3f, 0xa4, 0xe0, 0xc8, 0x23, 0xb4, 0x7c, 0x6b, 0x63, 0x0d, 0xb1, 0xc5, 0xf0, 0x55, 0x30,
7278         0x5b, 0x23, 0xd4, 0xf4, 0x49, 0x6d, 0x65, 0x67, 0xe3, 0xb6, 0xd0, 0xaf, 0x67, 0xb8, 0xc6, 0xf3,
7279         0x52, 0xe3, 0xec, 0x5a, 0x5a, 0x00, 0x75, 0xaf, 0x81, 0xdf, 0x02, 0x63, 0xee, 0xee, 0x1d, 0x62,
7280         0x04, 0x54, 0xcf, 0x2e, 0x64, 0x97, 0x26, 0xae, 0x5d, 0x29, 0xc7, 0x27, 0xa8, 0x4c, 0xe0, 0xc7,
7281         0x26, 0x37, 0x5b, 0x46, 0xf8, 0x60, 0x3d, 0x3a, 0xb9, 0xca, 0xb4, 0x44, 0x1b, 0xdb, 0x16, 0x5a,
7282         0x50, 0xa4, 0xae, 0xf4, 0x87, 0x0c, 0x80, 0xc9, 0xcd, 0x53, 0xcf, 0x75, 0x28, 0x19, 0xc8, 0xee,
7283         0x29, 0x98, 0x31, 0xb8, 0xe6, 0x80, 0xd4, 0x24, 0xae, 0x9e, 0xf9, 0x2c, 0xd6, 0xeb, 0x12, 0x7f,
7284         0x66, 0x35, 0xa5, 0x0e, 0x75, 0x01, 0xc0, 0x9b, 0x60, 0xd4, 0x27, 0x34, 0xb4, 0x02, 0x3d, 0xbb,
7285         0xa0, 0x2d, 0x4d, 0x5c, 0xbb, 0xdc, 0x17, 0x8a, 0xc7, 0x37, 0x0b, 0xbe, 0x72, 0xf3, 0x6a, 0xb9,
7286         0x1a, 0xe0, 0x20, 0xa4, 0x95, 0xd3, 0x12, 0x69, 0x14, 0x71, 0x1d, 0x48, 0xea, 0x2a, 0xfd, 0x38,
7287         0x03, 0x66, 0x92, 0x5e, 0x6a, 0x9a, 0xe4, 0x00, 0x1e, 0x80, 0x31, 0x5f, 0x04, 0x0b, 0xf7, 0xd3,
7288         0xc4, 0xb5, 0x9d, 0xf2, 0x63, 0xa5, 0x55, 0xb9, 0x2b, 0x08, 0x2b, 0x13, 0xec, 0xcc, 0xe4, 0x07,
7289         0x8a, 0xd0, 0xe0, 0xbb, 0x20, 0xef, 0xcb, 0x83, 0xe2, 0xd1, 0x34, 0x71, 0xed, 0x9b, 0x03, 0x44,
7290         0x16, 0x8a, 0x2b, 0x93, 0xed, 0x56, 0x31, 0x1f, 0x7d, 0x21, 0x05, 0x58, 0xfa, 0x28, 0x03, 0x0a,
7291         0xab, 0x21, 0x0d, 0x5c, 0x1b, 0x11, 0xea, 0x86, 0xbe, 0x41, 0x56, 0x5d, 0x2b, 0xb4, 0x9d, 0x35,
7292         0x52, 0x37, 0x1d, 0x33, 0x60, 0xd1, 0xba, 0x00, 0x46, 0x1c, 0x6c, 0x13, 0x19, 0x3d, 0x93, 0xd2,
7293         0xa7, 0x23, 0x5b, 0xd8, 0x26, 0x88, 0x73, 0x98, 0x04, 0x0b, 0x16, 0x99, 0x0b, 0x4a, 0xe2, 0xe6,
7294         0x91, 0x47, 0x10, 0xe7, 0xc0, 0x67, 0xc0, 0x68, 0xdd, 0xf5, 0x6d, 0x2c, 0xce, 0x71, 0x3c, 0x3e,
7295         0x99, 0x57, 0x38, 0x15, 0x49, 0x2e, 0x7c, 0x01, 0x4c, 0xd4, 0x08, 0x35, 0x7c, 0xd3, 0x63, 0xd0,
7296         0xfa, 0x08, 0x17, 0x3e, 0x23, 0x85, 0x27, 0xd6, 0x62, 0x16, 0x4a, 0xca, 0xc1, 0xcb, 0x20, 0xef,
7297         0xf9, 0xa6, 0xeb, 0x9b, 0xc1, 0x91, 0x9e, 0x5b, 0xd0, 0x96, 0x72, 0x95, 0x19, 0xb9, 0x26, 0xbf,
7298         0x23, 0xe9, 0x48, 0x49, 0xc0, 0x05, 0x90, 0xbf, 0x5e, 0xdd, 0xde, 0xda, 0xc1, 0xc1, 0x9e, 0x3e,
7299         0xca, 0x11, 0x46, 0x98, 0x34, 0xca, 0xdf, 0x91, 0xd4, 0xd2, 0x7b, 0x19, 0xa0, 0xa7, 0xbd, 0x12,
7300         0xb9, 0x14, 0xbe, 0x02, 0xf2, 0x34, 0x60, 0x15, 0xa7, 0x71, 0x24, 0x7d, 0xf2, 0x6c, 0x04, 0x56,
7301         0x95, 0xf4, 0xe3, 0x56, 0xf1, 0x5c, 0xbc, 0x22, 0xa2, 0x72, 0x7f, 0xa8, 0xb5, 0xf0, 0xb7, 0x1a,
7302         0x38, 0x73, 0x40, 0x76, 0xf7, 0x5c, 0x77, 0x7f, 0xd5, 0x32, 0x89, 0x13, 0xac, 0xba, 0x4e, 0xdd,
7303         0x6c, 0xc8, 0x18, 0x40, 0x8f, 0x19, 0x03, 0xaf, 0x75, 0x6b, 0xae, 0x3c, 0xd5, 0x6e, 0x15, 0xcf,
7304         0xf4, 0x60, 0xa0, 0x5e, 0x76, 0x94, 0xde, 0xcf, 0xa6, 0x9d, 0x90, 0x08, 0x8a, 0x77, 0x40, 0x9e,
7305         0x25, 0x5b, 0x0d, 0x07, 0x58, 0xa6, 0xcb, 0x73, 0x27, 0x4b, 0x4d, 0x91, 0xd9, 0x9b, 0x24, 0xc0,
7306         0x15, 0x28, 0xdd, 0x06, 0x62, 0x1a, 0x52, 0x5a, 0xe1, 0xf7, 0xc0, 0x08, 0xf5, 0x88, 0x21, 0xdd,
7307         0xf1, 0xfa, 0xe3, 0xa6, 0x44, 0x9f, 0x8d, 0x54, 0x3d, 0x62, 0xc4, 0x11, 0xcb, 0xbe, 0x10, 0x87,
7308         0x85, 0x1f, 0x68, 0x60, 0x94, 0xf2, 0x32, 0x22, 0x4b, 0xcf, 0x9b, 0xc3, 0xb2, 0x20, 0x55, 0xab,
7309         0xc4, 0x37, 0x92, 0xe0, 0xa5, 0xff, 0x64, 0xc0, 0x62, 0xbf, 0xa5, 0xab, 0xae, 0x53, 0x13, 0xc7,
7310         0xb1, 0x21, 0x33, 0x50, 0xc4, 0xe3, 0x0b, 0xc9, 0x0c, 0x3c, 0x6e, 0x15, 0x9f, 0x7e, 0xa4, 0x82,
7311         0x44, 0xaa, 0x7e, 0x4d, 0xed, 0x5b, 0xa4, 0xf3, 0x62, 0xa7, 0x61, 0xc7, 0xad, 0xe2, 0xb4, 0x5a,
7312         0xd6, 0x69, 0x2b, 0x6c, 0x02, 0x68, 0x61, 0x1a, 0xdc, 0xf4, 0xb1, 0x43, 0x85, 0x5a, 0xd3, 0x26,
7313         0xd2, 0x7d, 0xcf, 0x9e, 0x2c, 0x3c, 0xd8, 0x8a, 0xca, 0xbc, 0x84, 0x84, 0x37, 0xba, 0xb4, 0xa1,
7314         0x1e, 0x08, 0xac, 0xba, 0xf8, 0x04, 0x53, 0x55, 0x30, 0x12, 0x75, 0x9f, 0x51, 0x91, 0xe4, 0xc2,
7315         0x2f, 0x81, 0x31, 0x9b, 0x50, 0x8a, 0x1b, 0x84, 0x57, 0x89, 0xf1, 0xf8, 0x22, 0xdd, 0x14, 0x64,
7316         0x14, 0xf1, 0x59, 0x17, 0x71, 0xa1, 0x9f, 0xd7, 0x6e, 0x98, 0x34, 0x80, 0x6f, 0x74, 0x25, 0x40,
7317         0xf9, 0x64, 0x3b, 0x64, 0xab, 0x79, 0xf8, 0xab, 0x12, 0x15, 0x51, 0x12, 0xc1, 0xff, 0x5d, 0x90,
7318         0x33, 0x03, 0x62, 0x47, 0x37, 0xec, 0x6b, 0x43, 0x8a, 0xbd, 0xca, 0x94, 0xb4, 0x21, 0xb7, 0xc1,
7319         0xd0, 0x90, 0x00, 0x2d, 0xfd, 0x31, 0x03, 0x2e, 0xf6, 0x5b, 0xc2, 0xca, 0x3e, 0x65, 0x1e, 0xf7,
7320         0xac, 0xd0, 0xc7, 0x96, 0x8c, 0x38, 0xe5, 0xf1, 0x1d, 0x4e, 0x45, 0x92, 0xcb, 0x0a, 0x33, 0x35,
7321         0x9d, 0x46, 0x68, 0x61, 0x5f, 0x86, 0x93, 0xda, 0x75, 0x55, 0xd2, 0x91, 0x92, 0x80, 0x65, 0x00,
7322         0xe8, 0x9e, 0xeb, 0x07, 0x1c, 0x83, 0xb7, 0x46, 0xe3, 0x95, 0xd3, 0xac, 0x40, 0x54, 0x15, 0x15,
7323         0x25, 0x24, 0xd8, 0xbd, 0xb3, 0x6f, 0x3a, 0x35, 0x79, 0xea, 0x2a, 0x8b, 0xbf, 0x61, 0x3a, 0x35,
7324         0xc4, 0x39, 0x0c, 0xdf, 0x32, 0x69, 0xc0, 0x28, 0xf2, 0xc8, 0x3b, 0xbc, 0xce, 0x25, 0x95, 0x04,
7325         0xc3, 0x37, 0x58, 0x6d, 0x76, 0x7d, 0x93, 0x50, 0x7d, 0x34, 0xc6, 0x5f, 0x55, 0x54, 0x94, 0x90,
7326         0x28, 0xfd, 0x3a, 0xdf, 0x3f, 0x48, 0x58, 0x29, 0x81, 0x97, 0x40, 0xae, 0xe1, 0xbb, 0xa1, 0x27,
7327         0xbd, 0xa4, 0xbc, 0xfd, 0x2a, 0x23, 0x22, 0xc1, 0x63, 0x51, 0xd9, 0xec, 0x68, 0x26, 0x55, 0x54,
7328         0x46, 0x2d, 0x64, 0xc4, 0x87, 0x3f, 0xd4, 0x40, 0xce, 0x91, 0xce, 0x61, 0x21, 0xf7, 0xc6, 0x90,
7329         0xe2, 0x82, 0xbb, 0x37, 0x36, 0x57, 0x78, 0x5e, 0x20, 0xc3, 0xe7, 0x41, 0x8e, 0x1a, 0xae, 0x47,
7330         0xa4, 0xd7, 0x0b, 0x91, 0x50, 0x95, 0x11, 0x8f, 0x5b, 0xc5, 0xa9, 0x48, 0x1d, 0x27, 0x20, 0x21,
7331         0x0c, 0x7f, 0xa4, 0x01, 0xd0, 0xc4, 0x96, 0x59, 0xc3, 0xfc, 0x62, 0xcf, 0x71, 0xf3, 0x07, 0x1b,
7332         0xd6, 0xb7, 0x95, 0x7a, 0x71, 0x68, 0xf1, 0x37, 0x4a, 0x40, 0xc3, 0x0f, 0x35, 0x30, 0x49, 0xc3,
7333         0x5d, 0x5f, 0xae, 0xa2, 0xbc, 0x05, 0x98, 0xb8, 0xf6, 0xed, 0x81, 0xda, 0x52, 0x4d, 0x00, 0x54,
7334         0x66, 0xda, 0xad, 0xe2, 0x64, 0x92, 0x82, 0x3a, 0x0c, 0x80, 0x3f, 0xd5, 0x40, 0x5e, 0x9e, 0x30,
7335         0xd5, 0xc7, 0x78, 0xc2, 0xbf, 0x35, 0xa4, 0x83, 0x95, 0x11, 0x15, 0x67, 0x81, 0x24, 0x50, 0xa4,
7336         0x2c, 0x80, 0xff, 0xd0, 0x80, 0x8e, 0x6b, 0xa2, 0xc0, 0x63, 0x6b, 0xc7, 0x37, 0x9d, 0x80, 0xf8,
7337         0xa2, 0x2b, 0xa4, 0x7a, 0x9e, 0x9b, 0x37, 0xd8, 0xbb, 0x30, 0xdd, 0x71, 0x56, 0x16, 0xa4, 0x75,
7338         0xfa, 0x4a, 0x1f, 0x33, 0x50, 0x5f, 0x03, 0x79, 0xa0, 0x19, 0xaa, 0xf5, 0xd2, 0xc7, 0x87, 0x10,
7339         0x68, 0x71, 0x67, 0x27, 0xab, 0x43, 0xdc, 0x6e, 0x27, 0xa0, 0x4b, 0x1f, 0x66, 0xd3, 0xad, 0x75,
7340         0xfa, 0xd2, 0x87, 0xf7, 0x84, 0xb1, 0x62, 0x2b, 0x54, 0xd7, 0xb8, 0x73, 0xdf, 0x19, 0xd2, 0xd9,
7341         0xab, 0x5b, 0x3b, 0x6e, 0xbc, 0x14, 0x89, 0xa2, 0x84, 0x1d, 0xf0, 0x57, 0x1a, 0x98, 0xc2, 0x86,
7342         0x41, 0xbc, 0x80, 0xd4, 0x44, 0x2d, 0xce, 0x7c, 0x0e, 0xe5, 0x66, 0x4e, 0x5a, 0x35, 0xb5, 0x92,
7343         0x84, 0x46, 0x9d, 0x96, 0xc0, 0x97, 0xc1, 0x69, 0x1a, 0xb8, 0x3e, 0xa9, 0x45, 0x91, 0x2b, 0xef,
7344         0x09, 0xd8, 0x6e, 0x15, 0x4f, 0x57, 0x3b, 0x38, 0x28, 0x25, 0x59, 0xfa, 0x74, 0x04, 0x14, 0x1f,
7345         0x91, 0x19, 0x27, 0x78, 0xed, 0x3c, 0x03, 0x46, 0xf9, 0x76, 0x6b, 0xdc, 0x2b, 0xf9, 0x44, 0xe7,
7346         0xc6, 0xa9, 0x48, 0x72, 0x59, 0x5d, 0x67, 0xf8, 0xac, 0xdb, 0xc8, 0x72, 0x41, 0x55, 0xd7, 0xab,
7347         0x82, 0x8c, 0x22, 0x3e, 0x7c, 0x17, 0x8c, 0x8a, 0x69, 0x06, 0x2f, 0xaa, 0x43, 0x2c, 0x8c, 0x80,
7348         0xdb, 0xc9, 0xa1, 0x90, 0x84, 0xec, 0x2e, 0x88, 0xb9, 0x27, 0x5d, 0x10, 0x1f, 0x5a, 0x81, 0x46,
7349         0xff, 0xcf, 0x2b, 0x50, 0xe9, 0xbf, 0x5a, 0x3a, 0xef, 0x13, 0x5b, 0xad, 0x1a, 0xd8, 0x22, 0x70,
7350         0x0d, 0xcc, 0xb0, 0x47, 0x06, 0x22, 0x9e, 0x65, 0x1a, 0x98, 0xf2, 0x97, 0xa8, 0x08, 0x38, 0x35,
7351         0x1c, 0xa9, 0xa6, 0xf8, 0xa8, 0x6b, 0x05, 0xbc, 0x0e, 0xa0, 0x68, 0xbc, 0x3b, 0xf4, 0x88, 0x1e,
7352         0x42, 0xb5, 0xd0, 0xd5, 0x2e, 0x09, 0xd4, 0x63, 0x15, 0x5c, 0x05, 0xb3, 0x16, 0xde, 0x25, 0x56,
7353         0x95, 0x58, 0xc4, 0x08, 0x5c, 0x9f, 0xab, 0x12, 0x6f, 0xf5, 0xb9, 0x76, 0xab, 0x38, 0x7b, 0x23,
7354         0xcd, 0x44, 0xdd, 0xf2, 0xa5, 0xc5, 0x74, 0x7a, 0x25, 0x37, 0x2e, 0x9e, 0x33, 0xbf, 0xcb, 0x80,
7355         0xf9, 0xfe, 0x91, 0x01, 0xdf, 0x8b, 0x5f, 0x5d, 0xa2, 0xa9, 0x7e, 0x6b, 0x58, 0x51, 0x28, 0x9f,
7356         0x5d, 0xa0, 0xfb, 0xc9, 0x05, 0xbf, 0xcf, 0x3a, 0x1c, 0x6c, 0x45, 0xd3, 0x98, 0x37, 0x87, 0x66,
7357         0x02, 0x03, 0xa9, 0x8c, 0x8b, 0xe6, 0x09, 0x5b, 0xbc, 0x57, 0xc2, 0x16, 0x29, 0xfd, 0x49, 0x4b,
7358         0x3f, 0xbc, 0xe3, 0x0c, 0x86, 0x3f, 0xd3, 0xc0, 0xb4, 0xeb, 0x11, 0x67, 0x65, 0x67, 0xe3, 0xf6,
7359         0x57, 0x44, 0x26, 0x4b, 0x57, 0x6d, 0x3d, 0xa6, 0x9d, 0xd7, 0xab, 0xdb, 0x5b, 0x42, 0xe1, 0x8e,
7360         0xef, 0x7a, 0xb4, 0x72, 0xa6, 0xdd, 0x2a, 0x4e, 0x6f, 0x77, 0x42, 0xa1, 0x34, 0x76, 0xc9, 0x06,
7361         0x73, 0xeb, 0x87, 0x01, 0xf1, 0x1d, 0x6c, 0xad, 0xb9, 0x46, 0x68, 0x13, 0x27, 0x10, 0x86, 0xa6,
7362         0x46, 0x39, 0xda, 0x09, 0x47, 0x39, 0x17, 0x41, 0x36, 0xf4, 0x2d, 0x19, 0xc5, 0x13, 0x6a, 0x54,
7363         0x89, 0x6e, 0x20, 0x46, 0x2f, 0x2d, 0x82, 0x11, 0x66, 0x27, 0x3c, 0x0f, 0xb2, 0x3e, 0x3e, 0xe0,
7364         0x5a, 0x27, 0x2b, 0x63, 0x4c, 0x04, 0xe1, 0x03, 0xc4, 0x68, 0xa5, 0x3f, 0x5f, 0x00, 0xd3, 0xa9,
7365         0xbd, 0xc0, 0x79, 0x90, 0x51, 0xf3, 0x4f, 0x20, 0x95, 0x66, 0x36, 0xd6, 0x50, 0xc6, 0xac, 0xc1,
7366         0x17, 0x55, 0xf1, 0x15, 0xa0, 0x45, 0x55, 0xcf, 0x39, 0x95, 0xb5, 0xb4, 0xb1, 0x3a, 0x66, 0x48,
7367         0x54, 0x38, 0x99, 0x0d, 0xa4, 0x2e, 0xb3, 0x44, 0xd8, 0x40, 0xea, 0x88, 0xd1, 0x3e, 0xeb, 0x1c,
7368         0x2b, 0x1a, 0xa4, 0xe5, 0x4e, 0x30, 0x48, 0x1b, 0x7d, 0xe8, 0x20, 0xed, 0x12, 0xc8, 0x05, 0x66,
7369         0x60, 0x11, 0x7d, 0xac, 0xf3, 0xe5, 0x71, 0x93, 0x11, 0x91, 0xe0, 0xc1, 0x3b, 0x60, 0xac, 0x46,
7370         0xea, 0x38, 0xb4, 0x02, 0x3d, 0xcf, 0x43, 0x68, 0x75, 0x00, 0x21, 0x24, 0xa6, 0x9c, 0x6b, 0x42,
7371         0x2f, 0x8a, 0x00, 0xe0, 0xd3, 0x60, 0xcc, 0xc6, 0x87, 0xa6, 0x1d, 0xda, 0xbc, 0x27, 0xd3, 0x84,
7372         0xd8, 0xa6, 0x20, 0xa1, 0x88, 0xc7, 0x2a, 0x23, 0x39, 0x34, 0xac, 0x90, 0x9a, 0x4d, 0x22, 0x99,
7373         0x3a, 0xe0, 0xb7, 0xa7, 0xaa, 0x8c, 0xeb, 0x29, 0x3e, 0xea, 0x5a, 0xc1, 0xc1, 0x4c, 0x87, 0x2f,
7374         0x9e, 0x48, 0x80, 0x09, 0x12, 0x8a, 0x78, 0x9d, 0x60, 0x52, 0x7e, 0xb2, 0x1f, 0x98, 0x5c, 0xdc,
7375         0xb5, 0x02, 0x7e, 0x19, 0x8c, 0xdb, 0xf8, 0xf0, 0x06, 0x71, 0x1a, 0xc1, 0x9e, 0x3e, 0xb5, 0xa0,
7376         0x2d, 0x65, 0x2b, 0x53, 0xed, 0x56, 0x71, 0x7c, 0x33, 0x22, 0xa2, 0x98, 0xcf, 0x85, 0x4d, 0x47,
7377         0x0a, 0x9f, 0x4e, 0x08, 0x47, 0x44, 0x14, 0xf3, 0x59, 0x07, 0xe1, 0xe1, 0x80, 0x25, 0x97, 0x3e,
7378         0xdd, 0xf9, 0x32, 0xdc, 0x11, 0x64, 0x14, 0xf1, 0xe1, 0x12, 0xc8, 0xdb, 0xf8, 0x90, 0xbf, 0xe2,
7379         0xf5, 0x19, 0xae, 0x96, 0x4f, 0x7c, 0x37, 0x25, 0x0d, 0x29, 0x2e, 0x97, 0x34, 0x1d, 0x21, 0x39,
7380         0x9b, 0x90, 0x94, 0x34, 0xa4, 0xb8, 0x2c, 0x88, 0x43, 0xc7, 0xbc, 0x1b, 0x12, 0x21, 0x0c, 0xb9,
7381         0x67, 0x54, 0x10, 0xdf, 0x8a, 0x59, 0x28, 0x29, 0xc7, 0x5e, 0xd1, 0x76, 0x68, 0x05, 0xa6, 0x67,
7382         0x91, 0xed, 0xba, 0x7e, 0x86, 0xfb, 0x9f, 0xf7, 0xc9, 0x9b, 0x8a, 0x8a, 0x12, 0x12, 0x90, 0x80,
7383         0x11, 0xe2, 0x84, 0xb6, 0x7e, 0x96, 0x5f, 0xec, 0x03, 0x09, 0x41, 0x95, 0x39, 0xeb, 0x4e, 0x68,
7384         0x23, 0xae, 0x1e, 0xbe, 0x08, 0xa6, 0x6c, 0x7c, 0xc8, 0xca, 0x01, 0xf1, 0x03, 0xf6, 0xbe, 0x9f,
7385         0xe3, 0x9b, 0x9f, 0x65, 0x1d, 0xe7, 0x66, 0x92, 0x81, 0x3a, 0xe5, 0xf8, 0x42, 0xd3, 0x49, 0x2c,
7386         0x3c, 0x97, 0x58, 0x98, 0x64, 0xa0, 0x4e, 0x39, 0xe6, 0x69, 0x9f, 0xdc, 0x0d, 0x4d, 0x9f, 0xd4,
7387         0xf4, 0xa7, 0x78, 0x93, 0x2a, 0xa7, 0xf0, 0x82, 0x86, 0x14, 0x17, 0x36, 0xa3, 0x71, 0x8f, 0xce,
7388         0xd3, 0xf0, 0xd6, 0x60, 0x2b, 0xf9, 0xb6, 0xbf, 0xe2, 0xfb, 0xf8, 0x48, 0xdc, 0x34, 0xc9, 0x41,
7389         0x0f, 0xa4, 0x20, 0x87, 0x2d, 0x6b, 0xbb, 0xae, 0x9f, 0xe7, 0xbe, 0x1f, 0xf4, 0x0d, 0xa2, 0xaa,
7390         0xce, 0x0a, 0x03, 0x41, 0x02, 0x8b, 0x81, 0xba, 0x0e, 0x0b, 0x8d, 0xf9, 0xe1, 0x82, 0x6e, 0x33,
7391         0x10, 0x24, 0xb0, 0xf8, 0x4e, 0x9d, 0xa3, 0xed, 0xba, 0xfe, 0x85, 0x21, 0xef, 0x94, 0x81, 0x20,
7392         0x81, 0x05, 0x4d, 0x90, 0x75, 0xdc, 0x40, 0xbf, 0x30, 0x94, 0xeb, 0x99, 0x5f, 0x38, 0x5b, 0x6e,
7393         0x80, 0x18, 0x06, 0xfc, 0xa5, 0x06, 0x80, 0x17, 0x87, 0xe8, 0xc5, 0x81, 0x4c, 0x11, 0x52, 0x90,
7394         0xe5, 0x38, 0xb6, 0xd7, 0x9d, 0xc0, 0x3f, 0x8a, 0xdf, 0x91, 0x89, 0x1c, 0x48, 0x58, 0x01, 0x7f,
7395         0xaf, 0x81, 0xb3, 0xc9, 0x36, 0x59, 0x99, 0x57, 0xe0, 0x1e, 0xb9, 0x39, 0xe8, 0x30, 0xaf, 0xb8,
7396         0xae, 0x55, 0xd1, 0xdb, 0xad, 0xe2, 0xd9, 0x95, 0x1e, 0xa8, 0xa8, 0xa7, 0x2d, 0xf0, 0x2f, 0x1a,
7397         0x98, 0x95, 0x55, 0x34, 0x61, 0x61, 0x91, 0x3b, 0x90, 0x0c, 0xda, 0x81, 0x69, 0x1c, 0xe1, 0x47,
7398         0xf5, 0xeb, 0x71, 0x17, 0x1f, 0x75, 0x9b, 0x06, 0xff, 0xae, 0x81, 0xc9, 0x1a, 0xf1, 0x88, 0x53,
7399         0x23, 0x8e, 0xc1, 0x6c, 0x5d, 0x18, 0xc8, 0xd8, 0x20, 0x6d, 0xeb, 0x5a, 0x02, 0x42, 0x98, 0x59,
7400         0x96, 0x66, 0x4e, 0x26, 0x59, 0xc7, 0xad, 0xe2, 0xb9, 0x78, 0x69, 0x92, 0x83, 0x3a, 0xac, 0x84,
7401         0x1f, 0x69, 0x60, 0x3a, 0x3e, 0x00, 0x71, 0xa5, 0x2c, 0x0e, 0x31, 0x0e, 0x78, 0xfb, 0xba, 0xd2,
7402         0x09, 0x88, 0xd2, 0x16, 0xc0, 0xbf, 0x6a, 0xac, 0x53, 0x8b, 0xde, 0x7d, 0x54, 0x2f, 0x71, 0x5f,
7403         0xbe, 0x3d, 0x70, 0x5f, 0x2a, 0x04, 0xe1, 0xca, 0xcb, 0x71, 0x2b, 0xa8, 0x38, 0xc7, 0xad, 0xe2,
7404         0x5c, 0xd2, 0x93, 0x8a, 0x81, 0x92, 0x16, 0xc2, 0x9f, 0x68, 0x60, 0x92, 0xc4, 0x1d, 0x37, 0xd5,
7405         0x2f, 0x0d, 0xc4, 0x89, 0x3d, 0x9b, 0x78, 0xf1, 0x52, 0x4f, 0xb0, 0x28, 0xea, 0xc0, 0x66, 0x1d,
7406         0x24, 0x39, 0xc4, 0xb6, 0x67, 0x11, 0xfd, 0x8b, 0x03, 0xee, 0x20, 0xd7, 0x85, 0x5e, 0x14, 0x01,
7407         0xcc, 0xb3, 0x97, 0x4f, 0x2a, 0x73, 0xe0, 0x0c, 0xc8, 0xee, 0x13, 0xf9, 0x33, 0x2c, 0x62, 0x7f,
7408         0xc2, 0x1a, 0xc8, 0x35, 0xb1, 0x15, 0x46, 0x8f, 0xb7, 0x01, 0x57, 0x5d, 0x24, 0x94, 0xbf, 0x9c,
7409         0x79, 0x49, 0x9b, 0xbf, 0xa7, 0x81, 0x73, 0xbd, 0x13, 0xfa, 0x89, 0x9a, 0xf5, 0x1b, 0x0d, 0xcc,
7410         0x76, 0xe5, 0x6e, 0x0f, 0x8b, 0xee, 0x76, 0x5a, 0xf4, 0xfa, 0xa0, 0x93, 0xb0, 0x1a, 0xf8, 0xa6,
7411         0xd3, 0xe0, 0x9d, 0x47, 0xd2, 0xbc, 0x9f, 0x6b, 0x60, 0x26, 0x9d, 0x0e, 0x4f, 0xd2, 0x5f, 0xa5,
7412         0x7b, 0x19, 0x70, 0xae, 0x77, 0xc3, 0x04, 0x7d, 0xf5, 0x32, 0x1c, 0xce, 0x0b, 0xbb, 0xd7, 0x34,
7413         0xee, 0x03, 0x0d, 0x4c, 0xdc, 0x51, 0x72, 0xd1, 0x0f, 0x80, 0x03, 0x7f, 0xdb, 0x47, 0xf5, 0x27,
7414         0x66, 0x50, 0x94, 0xc4, 0x2d, 0xfd, 0x4d, 0x03, 0x73, 0x3d, 0x0b, 0x2b, 0x7b, 0x82, 0x62, 0xcb,
7415         0x72, 0x0f, 0xc4, 0x88, 0x26, 0x31, 0xff, 0x5c, 0xe1, 0x54, 0x24, 0xb9, 0x09, 0xef, 0x65, 0x3e,
7416         0x2f, 0xef, 0x95, 0xfe, 0xa9, 0x81, 0x0b, 0x0f, 0x8b, 0xc4, 0x27, 0x72, 0xa4, 0x4b, 0x20, 0x2f,
7417         0x9b, 0xa2, 0x23, 0x7e, 0x9c, 0xf2, 0x1d, 0x20, 0x8b, 0x06, 0xff, 0xcf, 0x14, 0xf1, 0x57, 0xe9,
7418         0x7d, 0x0d, 0xcc, 0x54, 0x89, 0xdf, 0x34, 0x0d, 0x82, 0x48, 0x9d, 0xf8, 0xc4, 0x31, 0x08, 0x5c,
7419         0x06, 0xe3, 0xfc, 0x97, 0x37, 0x0f, 0x1b, 0xd1, 0x58, 0x7a, 0x56, 0xba, 0x7c, 0x7c, 0x2b, 0x62,
7420         0xa0, 0x58, 0x46, 0x8d, 0xb0, 0x33, 0x7d, 0x47, 0xd8, 0x17, 0xc0, 0x88, 0x17, 0x0f, 0xf8, 0xf2,
7421         0x8c, 0xcb, 0x67, 0x7a, 0x9c, 0x5a, 0xfa, 0x97, 0x06, 0x7a, 0xfd, 0x97, 0x08, 0x6c, 0x82, 0x31,
7422         0x2a, 0x8c, 0x93, 0xce, 0xdb, 0x7e, 0x4c, 0xe7, 0xa5, 0xb7, 0x2a, 0x0a, 0x7f, 0x44, 0x8d, 0xc0,
7423         0x98, 0xff, 0x0c, 0x5c, 0x09, 0x9d, 0x9a, 0x1c, 0xc9, 0x4d, 0x0a, 0xff, 0xad, 0xae, 0x08, 0x1a,
7424         0x52, 0x5c, 0x78, 0x5e, 0x0c, 0x8f, 0x12, 0x13, 0x99, 0x68, 0x70, 0x54, 0xb9, 0x72, 0xff, 0x41,
7425         0xe1, 0xd4, 0xc7, 0x0f, 0x0a, 0xa7, 0x3e, 0x79, 0x50, 0x38, 0xf5, 0x83, 0x76, 0x41, 0xbb, 0xdf,
7426         0x2e, 0x68, 0x1f, 0xb7, 0x0b, 0xda, 0x27, 0xed, 0x82, 0xf6, 0xef, 0x76, 0x41, 0xfb, 0xc5, 0xa7,
7427         0x85, 0x53, 0xdf, 0x19, 0x93, 0xa6, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xc5, 0xe4, 0x3a,
7428         0xbb, 0x29, 0x00, 0x00,
7429 }