1
16
17
18
19
20 package v1beta1
21
22 import (
23 encoding_binary "encoding/binary"
24 fmt "fmt"
25
26 io "io"
27
28 proto "github.com/gogo/protobuf/proto"
29 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
30 runtime "k8s.io/apimachinery/pkg/runtime"
31
32 math "math"
33 math_bits "math/bits"
34 reflect "reflect"
35 strings "strings"
36
37 k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
38 )
39
40
41 var _ = proto.Marshal
42 var _ = fmt.Errorf
43 var _ = math.Inf
44
45
46
47
48
49 const _ = proto.GoGoProtoPackageIsVersion3
50
51 func (m *ConversionRequest) Reset() { *m = ConversionRequest{} }
52 func (*ConversionRequest) ProtoMessage() {}
53 func (*ConversionRequest) Descriptor() ([]byte, []int) {
54 return fileDescriptor_3623d6c0bd238430, []int{0}
55 }
56 func (m *ConversionRequest) XXX_Unmarshal(b []byte) error {
57 return m.Unmarshal(b)
58 }
59 func (m *ConversionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
60 b = b[:cap(b)]
61 n, err := m.MarshalToSizedBuffer(b)
62 if err != nil {
63 return nil, err
64 }
65 return b[:n], nil
66 }
67 func (m *ConversionRequest) XXX_Merge(src proto.Message) {
68 xxx_messageInfo_ConversionRequest.Merge(m, src)
69 }
70 func (m *ConversionRequest) XXX_Size() int {
71 return m.Size()
72 }
73 func (m *ConversionRequest) XXX_DiscardUnknown() {
74 xxx_messageInfo_ConversionRequest.DiscardUnknown(m)
75 }
76
77 var xxx_messageInfo_ConversionRequest proto.InternalMessageInfo
78
79 func (m *ConversionResponse) Reset() { *m = ConversionResponse{} }
80 func (*ConversionResponse) ProtoMessage() {}
81 func (*ConversionResponse) Descriptor() ([]byte, []int) {
82 return fileDescriptor_3623d6c0bd238430, []int{1}
83 }
84 func (m *ConversionResponse) XXX_Unmarshal(b []byte) error {
85 return m.Unmarshal(b)
86 }
87 func (m *ConversionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
88 b = b[:cap(b)]
89 n, err := m.MarshalToSizedBuffer(b)
90 if err != nil {
91 return nil, err
92 }
93 return b[:n], nil
94 }
95 func (m *ConversionResponse) XXX_Merge(src proto.Message) {
96 xxx_messageInfo_ConversionResponse.Merge(m, src)
97 }
98 func (m *ConversionResponse) XXX_Size() int {
99 return m.Size()
100 }
101 func (m *ConversionResponse) XXX_DiscardUnknown() {
102 xxx_messageInfo_ConversionResponse.DiscardUnknown(m)
103 }
104
105 var xxx_messageInfo_ConversionResponse proto.InternalMessageInfo
106
107 func (m *ConversionReview) Reset() { *m = ConversionReview{} }
108 func (*ConversionReview) ProtoMessage() {}
109 func (*ConversionReview) Descriptor() ([]byte, []int) {
110 return fileDescriptor_3623d6c0bd238430, []int{2}
111 }
112 func (m *ConversionReview) XXX_Unmarshal(b []byte) error {
113 return m.Unmarshal(b)
114 }
115 func (m *ConversionReview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
116 b = b[:cap(b)]
117 n, err := m.MarshalToSizedBuffer(b)
118 if err != nil {
119 return nil, err
120 }
121 return b[:n], nil
122 }
123 func (m *ConversionReview) XXX_Merge(src proto.Message) {
124 xxx_messageInfo_ConversionReview.Merge(m, src)
125 }
126 func (m *ConversionReview) XXX_Size() int {
127 return m.Size()
128 }
129 func (m *ConversionReview) XXX_DiscardUnknown() {
130 xxx_messageInfo_ConversionReview.DiscardUnknown(m)
131 }
132
133 var xxx_messageInfo_ConversionReview proto.InternalMessageInfo
134
135 func (m *CustomResourceColumnDefinition) Reset() { *m = CustomResourceColumnDefinition{} }
136 func (*CustomResourceColumnDefinition) ProtoMessage() {}
137 func (*CustomResourceColumnDefinition) Descriptor() ([]byte, []int) {
138 return fileDescriptor_3623d6c0bd238430, []int{3}
139 }
140 func (m *CustomResourceColumnDefinition) XXX_Unmarshal(b []byte) error {
141 return m.Unmarshal(b)
142 }
143 func (m *CustomResourceColumnDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
144 b = b[:cap(b)]
145 n, err := m.MarshalToSizedBuffer(b)
146 if err != nil {
147 return nil, err
148 }
149 return b[:n], nil
150 }
151 func (m *CustomResourceColumnDefinition) XXX_Merge(src proto.Message) {
152 xxx_messageInfo_CustomResourceColumnDefinition.Merge(m, src)
153 }
154 func (m *CustomResourceColumnDefinition) XXX_Size() int {
155 return m.Size()
156 }
157 func (m *CustomResourceColumnDefinition) XXX_DiscardUnknown() {
158 xxx_messageInfo_CustomResourceColumnDefinition.DiscardUnknown(m)
159 }
160
161 var xxx_messageInfo_CustomResourceColumnDefinition proto.InternalMessageInfo
162
163 func (m *CustomResourceConversion) Reset() { *m = CustomResourceConversion{} }
164 func (*CustomResourceConversion) ProtoMessage() {}
165 func (*CustomResourceConversion) Descriptor() ([]byte, []int) {
166 return fileDescriptor_3623d6c0bd238430, []int{4}
167 }
168 func (m *CustomResourceConversion) XXX_Unmarshal(b []byte) error {
169 return m.Unmarshal(b)
170 }
171 func (m *CustomResourceConversion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
172 b = b[:cap(b)]
173 n, err := m.MarshalToSizedBuffer(b)
174 if err != nil {
175 return nil, err
176 }
177 return b[:n], nil
178 }
179 func (m *CustomResourceConversion) XXX_Merge(src proto.Message) {
180 xxx_messageInfo_CustomResourceConversion.Merge(m, src)
181 }
182 func (m *CustomResourceConversion) XXX_Size() int {
183 return m.Size()
184 }
185 func (m *CustomResourceConversion) XXX_DiscardUnknown() {
186 xxx_messageInfo_CustomResourceConversion.DiscardUnknown(m)
187 }
188
189 var xxx_messageInfo_CustomResourceConversion proto.InternalMessageInfo
190
191 func (m *CustomResourceDefinition) Reset() { *m = CustomResourceDefinition{} }
192 func (*CustomResourceDefinition) ProtoMessage() {}
193 func (*CustomResourceDefinition) Descriptor() ([]byte, []int) {
194 return fileDescriptor_3623d6c0bd238430, []int{5}
195 }
196 func (m *CustomResourceDefinition) XXX_Unmarshal(b []byte) error {
197 return m.Unmarshal(b)
198 }
199 func (m *CustomResourceDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
200 b = b[:cap(b)]
201 n, err := m.MarshalToSizedBuffer(b)
202 if err != nil {
203 return nil, err
204 }
205 return b[:n], nil
206 }
207 func (m *CustomResourceDefinition) XXX_Merge(src proto.Message) {
208 xxx_messageInfo_CustomResourceDefinition.Merge(m, src)
209 }
210 func (m *CustomResourceDefinition) XXX_Size() int {
211 return m.Size()
212 }
213 func (m *CustomResourceDefinition) XXX_DiscardUnknown() {
214 xxx_messageInfo_CustomResourceDefinition.DiscardUnknown(m)
215 }
216
217 var xxx_messageInfo_CustomResourceDefinition proto.InternalMessageInfo
218
219 func (m *CustomResourceDefinitionCondition) Reset() { *m = CustomResourceDefinitionCondition{} }
220 func (*CustomResourceDefinitionCondition) ProtoMessage() {}
221 func (*CustomResourceDefinitionCondition) Descriptor() ([]byte, []int) {
222 return fileDescriptor_3623d6c0bd238430, []int{6}
223 }
224 func (m *CustomResourceDefinitionCondition) XXX_Unmarshal(b []byte) error {
225 return m.Unmarshal(b)
226 }
227 func (m *CustomResourceDefinitionCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
228 b = b[:cap(b)]
229 n, err := m.MarshalToSizedBuffer(b)
230 if err != nil {
231 return nil, err
232 }
233 return b[:n], nil
234 }
235 func (m *CustomResourceDefinitionCondition) XXX_Merge(src proto.Message) {
236 xxx_messageInfo_CustomResourceDefinitionCondition.Merge(m, src)
237 }
238 func (m *CustomResourceDefinitionCondition) XXX_Size() int {
239 return m.Size()
240 }
241 func (m *CustomResourceDefinitionCondition) XXX_DiscardUnknown() {
242 xxx_messageInfo_CustomResourceDefinitionCondition.DiscardUnknown(m)
243 }
244
245 var xxx_messageInfo_CustomResourceDefinitionCondition proto.InternalMessageInfo
246
247 func (m *CustomResourceDefinitionList) Reset() { *m = CustomResourceDefinitionList{} }
248 func (*CustomResourceDefinitionList) ProtoMessage() {}
249 func (*CustomResourceDefinitionList) Descriptor() ([]byte, []int) {
250 return fileDescriptor_3623d6c0bd238430, []int{7}
251 }
252 func (m *CustomResourceDefinitionList) XXX_Unmarshal(b []byte) error {
253 return m.Unmarshal(b)
254 }
255 func (m *CustomResourceDefinitionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
256 b = b[:cap(b)]
257 n, err := m.MarshalToSizedBuffer(b)
258 if err != nil {
259 return nil, err
260 }
261 return b[:n], nil
262 }
263 func (m *CustomResourceDefinitionList) XXX_Merge(src proto.Message) {
264 xxx_messageInfo_CustomResourceDefinitionList.Merge(m, src)
265 }
266 func (m *CustomResourceDefinitionList) XXX_Size() int {
267 return m.Size()
268 }
269 func (m *CustomResourceDefinitionList) XXX_DiscardUnknown() {
270 xxx_messageInfo_CustomResourceDefinitionList.DiscardUnknown(m)
271 }
272
273 var xxx_messageInfo_CustomResourceDefinitionList proto.InternalMessageInfo
274
275 func (m *CustomResourceDefinitionNames) Reset() { *m = CustomResourceDefinitionNames{} }
276 func (*CustomResourceDefinitionNames) ProtoMessage() {}
277 func (*CustomResourceDefinitionNames) Descriptor() ([]byte, []int) {
278 return fileDescriptor_3623d6c0bd238430, []int{8}
279 }
280 func (m *CustomResourceDefinitionNames) XXX_Unmarshal(b []byte) error {
281 return m.Unmarshal(b)
282 }
283 func (m *CustomResourceDefinitionNames) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
284 b = b[:cap(b)]
285 n, err := m.MarshalToSizedBuffer(b)
286 if err != nil {
287 return nil, err
288 }
289 return b[:n], nil
290 }
291 func (m *CustomResourceDefinitionNames) XXX_Merge(src proto.Message) {
292 xxx_messageInfo_CustomResourceDefinitionNames.Merge(m, src)
293 }
294 func (m *CustomResourceDefinitionNames) XXX_Size() int {
295 return m.Size()
296 }
297 func (m *CustomResourceDefinitionNames) XXX_DiscardUnknown() {
298 xxx_messageInfo_CustomResourceDefinitionNames.DiscardUnknown(m)
299 }
300
301 var xxx_messageInfo_CustomResourceDefinitionNames proto.InternalMessageInfo
302
303 func (m *CustomResourceDefinitionSpec) Reset() { *m = CustomResourceDefinitionSpec{} }
304 func (*CustomResourceDefinitionSpec) ProtoMessage() {}
305 func (*CustomResourceDefinitionSpec) Descriptor() ([]byte, []int) {
306 return fileDescriptor_3623d6c0bd238430, []int{9}
307 }
308 func (m *CustomResourceDefinitionSpec) XXX_Unmarshal(b []byte) error {
309 return m.Unmarshal(b)
310 }
311 func (m *CustomResourceDefinitionSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
312 b = b[:cap(b)]
313 n, err := m.MarshalToSizedBuffer(b)
314 if err != nil {
315 return nil, err
316 }
317 return b[:n], nil
318 }
319 func (m *CustomResourceDefinitionSpec) XXX_Merge(src proto.Message) {
320 xxx_messageInfo_CustomResourceDefinitionSpec.Merge(m, src)
321 }
322 func (m *CustomResourceDefinitionSpec) XXX_Size() int {
323 return m.Size()
324 }
325 func (m *CustomResourceDefinitionSpec) XXX_DiscardUnknown() {
326 xxx_messageInfo_CustomResourceDefinitionSpec.DiscardUnknown(m)
327 }
328
329 var xxx_messageInfo_CustomResourceDefinitionSpec proto.InternalMessageInfo
330
331 func (m *CustomResourceDefinitionStatus) Reset() { *m = CustomResourceDefinitionStatus{} }
332 func (*CustomResourceDefinitionStatus) ProtoMessage() {}
333 func (*CustomResourceDefinitionStatus) Descriptor() ([]byte, []int) {
334 return fileDescriptor_3623d6c0bd238430, []int{10}
335 }
336 func (m *CustomResourceDefinitionStatus) XXX_Unmarshal(b []byte) error {
337 return m.Unmarshal(b)
338 }
339 func (m *CustomResourceDefinitionStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
340 b = b[:cap(b)]
341 n, err := m.MarshalToSizedBuffer(b)
342 if err != nil {
343 return nil, err
344 }
345 return b[:n], nil
346 }
347 func (m *CustomResourceDefinitionStatus) XXX_Merge(src proto.Message) {
348 xxx_messageInfo_CustomResourceDefinitionStatus.Merge(m, src)
349 }
350 func (m *CustomResourceDefinitionStatus) XXX_Size() int {
351 return m.Size()
352 }
353 func (m *CustomResourceDefinitionStatus) XXX_DiscardUnknown() {
354 xxx_messageInfo_CustomResourceDefinitionStatus.DiscardUnknown(m)
355 }
356
357 var xxx_messageInfo_CustomResourceDefinitionStatus proto.InternalMessageInfo
358
359 func (m *CustomResourceDefinitionVersion) Reset() { *m = CustomResourceDefinitionVersion{} }
360 func (*CustomResourceDefinitionVersion) ProtoMessage() {}
361 func (*CustomResourceDefinitionVersion) Descriptor() ([]byte, []int) {
362 return fileDescriptor_3623d6c0bd238430, []int{11}
363 }
364 func (m *CustomResourceDefinitionVersion) XXX_Unmarshal(b []byte) error {
365 return m.Unmarshal(b)
366 }
367 func (m *CustomResourceDefinitionVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
368 b = b[:cap(b)]
369 n, err := m.MarshalToSizedBuffer(b)
370 if err != nil {
371 return nil, err
372 }
373 return b[:n], nil
374 }
375 func (m *CustomResourceDefinitionVersion) XXX_Merge(src proto.Message) {
376 xxx_messageInfo_CustomResourceDefinitionVersion.Merge(m, src)
377 }
378 func (m *CustomResourceDefinitionVersion) XXX_Size() int {
379 return m.Size()
380 }
381 func (m *CustomResourceDefinitionVersion) XXX_DiscardUnknown() {
382 xxx_messageInfo_CustomResourceDefinitionVersion.DiscardUnknown(m)
383 }
384
385 var xxx_messageInfo_CustomResourceDefinitionVersion proto.InternalMessageInfo
386
387 func (m *CustomResourceSubresourceScale) Reset() { *m = CustomResourceSubresourceScale{} }
388 func (*CustomResourceSubresourceScale) ProtoMessage() {}
389 func (*CustomResourceSubresourceScale) Descriptor() ([]byte, []int) {
390 return fileDescriptor_3623d6c0bd238430, []int{12}
391 }
392 func (m *CustomResourceSubresourceScale) XXX_Unmarshal(b []byte) error {
393 return m.Unmarshal(b)
394 }
395 func (m *CustomResourceSubresourceScale) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
396 b = b[:cap(b)]
397 n, err := m.MarshalToSizedBuffer(b)
398 if err != nil {
399 return nil, err
400 }
401 return b[:n], nil
402 }
403 func (m *CustomResourceSubresourceScale) XXX_Merge(src proto.Message) {
404 xxx_messageInfo_CustomResourceSubresourceScale.Merge(m, src)
405 }
406 func (m *CustomResourceSubresourceScale) XXX_Size() int {
407 return m.Size()
408 }
409 func (m *CustomResourceSubresourceScale) XXX_DiscardUnknown() {
410 xxx_messageInfo_CustomResourceSubresourceScale.DiscardUnknown(m)
411 }
412
413 var xxx_messageInfo_CustomResourceSubresourceScale proto.InternalMessageInfo
414
415 func (m *CustomResourceSubresourceStatus) Reset() { *m = CustomResourceSubresourceStatus{} }
416 func (*CustomResourceSubresourceStatus) ProtoMessage() {}
417 func (*CustomResourceSubresourceStatus) Descriptor() ([]byte, []int) {
418 return fileDescriptor_3623d6c0bd238430, []int{13}
419 }
420 func (m *CustomResourceSubresourceStatus) XXX_Unmarshal(b []byte) error {
421 return m.Unmarshal(b)
422 }
423 func (m *CustomResourceSubresourceStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
424 b = b[:cap(b)]
425 n, err := m.MarshalToSizedBuffer(b)
426 if err != nil {
427 return nil, err
428 }
429 return b[:n], nil
430 }
431 func (m *CustomResourceSubresourceStatus) XXX_Merge(src proto.Message) {
432 xxx_messageInfo_CustomResourceSubresourceStatus.Merge(m, src)
433 }
434 func (m *CustomResourceSubresourceStatus) XXX_Size() int {
435 return m.Size()
436 }
437 func (m *CustomResourceSubresourceStatus) XXX_DiscardUnknown() {
438 xxx_messageInfo_CustomResourceSubresourceStatus.DiscardUnknown(m)
439 }
440
441 var xxx_messageInfo_CustomResourceSubresourceStatus proto.InternalMessageInfo
442
443 func (m *CustomResourceSubresources) Reset() { *m = CustomResourceSubresources{} }
444 func (*CustomResourceSubresources) ProtoMessage() {}
445 func (*CustomResourceSubresources) Descriptor() ([]byte, []int) {
446 return fileDescriptor_3623d6c0bd238430, []int{14}
447 }
448 func (m *CustomResourceSubresources) XXX_Unmarshal(b []byte) error {
449 return m.Unmarshal(b)
450 }
451 func (m *CustomResourceSubresources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
452 b = b[:cap(b)]
453 n, err := m.MarshalToSizedBuffer(b)
454 if err != nil {
455 return nil, err
456 }
457 return b[:n], nil
458 }
459 func (m *CustomResourceSubresources) XXX_Merge(src proto.Message) {
460 xxx_messageInfo_CustomResourceSubresources.Merge(m, src)
461 }
462 func (m *CustomResourceSubresources) XXX_Size() int {
463 return m.Size()
464 }
465 func (m *CustomResourceSubresources) XXX_DiscardUnknown() {
466 xxx_messageInfo_CustomResourceSubresources.DiscardUnknown(m)
467 }
468
469 var xxx_messageInfo_CustomResourceSubresources proto.InternalMessageInfo
470
471 func (m *CustomResourceValidation) Reset() { *m = CustomResourceValidation{} }
472 func (*CustomResourceValidation) ProtoMessage() {}
473 func (*CustomResourceValidation) Descriptor() ([]byte, []int) {
474 return fileDescriptor_3623d6c0bd238430, []int{15}
475 }
476 func (m *CustomResourceValidation) XXX_Unmarshal(b []byte) error {
477 return m.Unmarshal(b)
478 }
479 func (m *CustomResourceValidation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
480 b = b[:cap(b)]
481 n, err := m.MarshalToSizedBuffer(b)
482 if err != nil {
483 return nil, err
484 }
485 return b[:n], nil
486 }
487 func (m *CustomResourceValidation) XXX_Merge(src proto.Message) {
488 xxx_messageInfo_CustomResourceValidation.Merge(m, src)
489 }
490 func (m *CustomResourceValidation) XXX_Size() int {
491 return m.Size()
492 }
493 func (m *CustomResourceValidation) XXX_DiscardUnknown() {
494 xxx_messageInfo_CustomResourceValidation.DiscardUnknown(m)
495 }
496
497 var xxx_messageInfo_CustomResourceValidation proto.InternalMessageInfo
498
499 func (m *ExternalDocumentation) Reset() { *m = ExternalDocumentation{} }
500 func (*ExternalDocumentation) ProtoMessage() {}
501 func (*ExternalDocumentation) Descriptor() ([]byte, []int) {
502 return fileDescriptor_3623d6c0bd238430, []int{16}
503 }
504 func (m *ExternalDocumentation) XXX_Unmarshal(b []byte) error {
505 return m.Unmarshal(b)
506 }
507 func (m *ExternalDocumentation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
508 b = b[:cap(b)]
509 n, err := m.MarshalToSizedBuffer(b)
510 if err != nil {
511 return nil, err
512 }
513 return b[:n], nil
514 }
515 func (m *ExternalDocumentation) XXX_Merge(src proto.Message) {
516 xxx_messageInfo_ExternalDocumentation.Merge(m, src)
517 }
518 func (m *ExternalDocumentation) XXX_Size() int {
519 return m.Size()
520 }
521 func (m *ExternalDocumentation) XXX_DiscardUnknown() {
522 xxx_messageInfo_ExternalDocumentation.DiscardUnknown(m)
523 }
524
525 var xxx_messageInfo_ExternalDocumentation proto.InternalMessageInfo
526
527 func (m *JSON) Reset() { *m = JSON{} }
528 func (*JSON) ProtoMessage() {}
529 func (*JSON) Descriptor() ([]byte, []int) {
530 return fileDescriptor_3623d6c0bd238430, []int{17}
531 }
532 func (m *JSON) XXX_Unmarshal(b []byte) error {
533 return m.Unmarshal(b)
534 }
535 func (m *JSON) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
536 b = b[:cap(b)]
537 n, err := m.MarshalToSizedBuffer(b)
538 if err != nil {
539 return nil, err
540 }
541 return b[:n], nil
542 }
543 func (m *JSON) XXX_Merge(src proto.Message) {
544 xxx_messageInfo_JSON.Merge(m, src)
545 }
546 func (m *JSON) XXX_Size() int {
547 return m.Size()
548 }
549 func (m *JSON) XXX_DiscardUnknown() {
550 xxx_messageInfo_JSON.DiscardUnknown(m)
551 }
552
553 var xxx_messageInfo_JSON proto.InternalMessageInfo
554
555 func (m *JSONSchemaProps) Reset() { *m = JSONSchemaProps{} }
556 func (*JSONSchemaProps) ProtoMessage() {}
557 func (*JSONSchemaProps) Descriptor() ([]byte, []int) {
558 return fileDescriptor_3623d6c0bd238430, []int{18}
559 }
560 func (m *JSONSchemaProps) XXX_Unmarshal(b []byte) error {
561 return m.Unmarshal(b)
562 }
563 func (m *JSONSchemaProps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
564 b = b[:cap(b)]
565 n, err := m.MarshalToSizedBuffer(b)
566 if err != nil {
567 return nil, err
568 }
569 return b[:n], nil
570 }
571 func (m *JSONSchemaProps) XXX_Merge(src proto.Message) {
572 xxx_messageInfo_JSONSchemaProps.Merge(m, src)
573 }
574 func (m *JSONSchemaProps) XXX_Size() int {
575 return m.Size()
576 }
577 func (m *JSONSchemaProps) XXX_DiscardUnknown() {
578 xxx_messageInfo_JSONSchemaProps.DiscardUnknown(m)
579 }
580
581 var xxx_messageInfo_JSONSchemaProps proto.InternalMessageInfo
582
583 func (m *JSONSchemaPropsOrArray) Reset() { *m = JSONSchemaPropsOrArray{} }
584 func (*JSONSchemaPropsOrArray) ProtoMessage() {}
585 func (*JSONSchemaPropsOrArray) Descriptor() ([]byte, []int) {
586 return fileDescriptor_3623d6c0bd238430, []int{19}
587 }
588 func (m *JSONSchemaPropsOrArray) XXX_Unmarshal(b []byte) error {
589 return m.Unmarshal(b)
590 }
591 func (m *JSONSchemaPropsOrArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
592 b = b[:cap(b)]
593 n, err := m.MarshalToSizedBuffer(b)
594 if err != nil {
595 return nil, err
596 }
597 return b[:n], nil
598 }
599 func (m *JSONSchemaPropsOrArray) XXX_Merge(src proto.Message) {
600 xxx_messageInfo_JSONSchemaPropsOrArray.Merge(m, src)
601 }
602 func (m *JSONSchemaPropsOrArray) XXX_Size() int {
603 return m.Size()
604 }
605 func (m *JSONSchemaPropsOrArray) XXX_DiscardUnknown() {
606 xxx_messageInfo_JSONSchemaPropsOrArray.DiscardUnknown(m)
607 }
608
609 var xxx_messageInfo_JSONSchemaPropsOrArray proto.InternalMessageInfo
610
611 func (m *JSONSchemaPropsOrBool) Reset() { *m = JSONSchemaPropsOrBool{} }
612 func (*JSONSchemaPropsOrBool) ProtoMessage() {}
613 func (*JSONSchemaPropsOrBool) Descriptor() ([]byte, []int) {
614 return fileDescriptor_3623d6c0bd238430, []int{20}
615 }
616 func (m *JSONSchemaPropsOrBool) XXX_Unmarshal(b []byte) error {
617 return m.Unmarshal(b)
618 }
619 func (m *JSONSchemaPropsOrBool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
620 b = b[:cap(b)]
621 n, err := m.MarshalToSizedBuffer(b)
622 if err != nil {
623 return nil, err
624 }
625 return b[:n], nil
626 }
627 func (m *JSONSchemaPropsOrBool) XXX_Merge(src proto.Message) {
628 xxx_messageInfo_JSONSchemaPropsOrBool.Merge(m, src)
629 }
630 func (m *JSONSchemaPropsOrBool) XXX_Size() int {
631 return m.Size()
632 }
633 func (m *JSONSchemaPropsOrBool) XXX_DiscardUnknown() {
634 xxx_messageInfo_JSONSchemaPropsOrBool.DiscardUnknown(m)
635 }
636
637 var xxx_messageInfo_JSONSchemaPropsOrBool proto.InternalMessageInfo
638
639 func (m *JSONSchemaPropsOrStringArray) Reset() { *m = JSONSchemaPropsOrStringArray{} }
640 func (*JSONSchemaPropsOrStringArray) ProtoMessage() {}
641 func (*JSONSchemaPropsOrStringArray) Descriptor() ([]byte, []int) {
642 return fileDescriptor_3623d6c0bd238430, []int{21}
643 }
644 func (m *JSONSchemaPropsOrStringArray) XXX_Unmarshal(b []byte) error {
645 return m.Unmarshal(b)
646 }
647 func (m *JSONSchemaPropsOrStringArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
648 b = b[:cap(b)]
649 n, err := m.MarshalToSizedBuffer(b)
650 if err != nil {
651 return nil, err
652 }
653 return b[:n], nil
654 }
655 func (m *JSONSchemaPropsOrStringArray) XXX_Merge(src proto.Message) {
656 xxx_messageInfo_JSONSchemaPropsOrStringArray.Merge(m, src)
657 }
658 func (m *JSONSchemaPropsOrStringArray) XXX_Size() int {
659 return m.Size()
660 }
661 func (m *JSONSchemaPropsOrStringArray) XXX_DiscardUnknown() {
662 xxx_messageInfo_JSONSchemaPropsOrStringArray.DiscardUnknown(m)
663 }
664
665 var xxx_messageInfo_JSONSchemaPropsOrStringArray proto.InternalMessageInfo
666
667 func (m *SelectableField) Reset() { *m = SelectableField{} }
668 func (*SelectableField) ProtoMessage() {}
669 func (*SelectableField) Descriptor() ([]byte, []int) {
670 return fileDescriptor_3623d6c0bd238430, []int{22}
671 }
672 func (m *SelectableField) XXX_Unmarshal(b []byte) error {
673 return m.Unmarshal(b)
674 }
675 func (m *SelectableField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
676 b = b[:cap(b)]
677 n, err := m.MarshalToSizedBuffer(b)
678 if err != nil {
679 return nil, err
680 }
681 return b[:n], nil
682 }
683 func (m *SelectableField) XXX_Merge(src proto.Message) {
684 xxx_messageInfo_SelectableField.Merge(m, src)
685 }
686 func (m *SelectableField) XXX_Size() int {
687 return m.Size()
688 }
689 func (m *SelectableField) XXX_DiscardUnknown() {
690 xxx_messageInfo_SelectableField.DiscardUnknown(m)
691 }
692
693 var xxx_messageInfo_SelectableField proto.InternalMessageInfo
694
695 func (m *ServiceReference) Reset() { *m = ServiceReference{} }
696 func (*ServiceReference) ProtoMessage() {}
697 func (*ServiceReference) Descriptor() ([]byte, []int) {
698 return fileDescriptor_3623d6c0bd238430, []int{23}
699 }
700 func (m *ServiceReference) XXX_Unmarshal(b []byte) error {
701 return m.Unmarshal(b)
702 }
703 func (m *ServiceReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
704 b = b[:cap(b)]
705 n, err := m.MarshalToSizedBuffer(b)
706 if err != nil {
707 return nil, err
708 }
709 return b[:n], nil
710 }
711 func (m *ServiceReference) XXX_Merge(src proto.Message) {
712 xxx_messageInfo_ServiceReference.Merge(m, src)
713 }
714 func (m *ServiceReference) XXX_Size() int {
715 return m.Size()
716 }
717 func (m *ServiceReference) XXX_DiscardUnknown() {
718 xxx_messageInfo_ServiceReference.DiscardUnknown(m)
719 }
720
721 var xxx_messageInfo_ServiceReference proto.InternalMessageInfo
722
723 func (m *ValidationRule) Reset() { *m = ValidationRule{} }
724 func (*ValidationRule) ProtoMessage() {}
725 func (*ValidationRule) Descriptor() ([]byte, []int) {
726 return fileDescriptor_3623d6c0bd238430, []int{24}
727 }
728 func (m *ValidationRule) XXX_Unmarshal(b []byte) error {
729 return m.Unmarshal(b)
730 }
731 func (m *ValidationRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
732 b = b[:cap(b)]
733 n, err := m.MarshalToSizedBuffer(b)
734 if err != nil {
735 return nil, err
736 }
737 return b[:n], nil
738 }
739 func (m *ValidationRule) XXX_Merge(src proto.Message) {
740 xxx_messageInfo_ValidationRule.Merge(m, src)
741 }
742 func (m *ValidationRule) XXX_Size() int {
743 return m.Size()
744 }
745 func (m *ValidationRule) XXX_DiscardUnknown() {
746 xxx_messageInfo_ValidationRule.DiscardUnknown(m)
747 }
748
749 var xxx_messageInfo_ValidationRule proto.InternalMessageInfo
750
751 func (m *WebhookClientConfig) Reset() { *m = WebhookClientConfig{} }
752 func (*WebhookClientConfig) ProtoMessage() {}
753 func (*WebhookClientConfig) Descriptor() ([]byte, []int) {
754 return fileDescriptor_3623d6c0bd238430, []int{25}
755 }
756 func (m *WebhookClientConfig) XXX_Unmarshal(b []byte) error {
757 return m.Unmarshal(b)
758 }
759 func (m *WebhookClientConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
760 b = b[:cap(b)]
761 n, err := m.MarshalToSizedBuffer(b)
762 if err != nil {
763 return nil, err
764 }
765 return b[:n], nil
766 }
767 func (m *WebhookClientConfig) XXX_Merge(src proto.Message) {
768 xxx_messageInfo_WebhookClientConfig.Merge(m, src)
769 }
770 func (m *WebhookClientConfig) XXX_Size() int {
771 return m.Size()
772 }
773 func (m *WebhookClientConfig) XXX_DiscardUnknown() {
774 xxx_messageInfo_WebhookClientConfig.DiscardUnknown(m)
775 }
776
777 var xxx_messageInfo_WebhookClientConfig proto.InternalMessageInfo
778
779 func init() {
780 proto.RegisterType((*ConversionRequest)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ConversionRequest")
781 proto.RegisterType((*ConversionResponse)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ConversionResponse")
782 proto.RegisterType((*ConversionReview)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ConversionReview")
783 proto.RegisterType((*CustomResourceColumnDefinition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceColumnDefinition")
784 proto.RegisterType((*CustomResourceConversion)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceConversion")
785 proto.RegisterType((*CustomResourceDefinition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinition")
786 proto.RegisterType((*CustomResourceDefinitionCondition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionCondition")
787 proto.RegisterType((*CustomResourceDefinitionList)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionList")
788 proto.RegisterType((*CustomResourceDefinitionNames)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionNames")
789 proto.RegisterType((*CustomResourceDefinitionSpec)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionSpec")
790 proto.RegisterType((*CustomResourceDefinitionStatus)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionStatus")
791 proto.RegisterType((*CustomResourceDefinitionVersion)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionVersion")
792 proto.RegisterType((*CustomResourceSubresourceScale)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresourceScale")
793 proto.RegisterType((*CustomResourceSubresourceStatus)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresourceStatus")
794 proto.RegisterType((*CustomResourceSubresources)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresources")
795 proto.RegisterType((*CustomResourceValidation)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceValidation")
796 proto.RegisterType((*ExternalDocumentation)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ExternalDocumentation")
797 proto.RegisterType((*JSON)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSON")
798 proto.RegisterType((*JSONSchemaProps)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps")
799 proto.RegisterMapType((JSONSchemaDefinitions)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps.DefinitionsEntry")
800 proto.RegisterMapType((JSONSchemaDependencies)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps.DependenciesEntry")
801 proto.RegisterMapType((map[string]JSONSchemaProps)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps.PatternPropertiesEntry")
802 proto.RegisterMapType((map[string]JSONSchemaProps)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps.PropertiesEntry")
803 proto.RegisterType((*JSONSchemaPropsOrArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrArray")
804 proto.RegisterType((*JSONSchemaPropsOrBool)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrBool")
805 proto.RegisterType((*JSONSchemaPropsOrStringArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrStringArray")
806 proto.RegisterType((*SelectableField)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.SelectableField")
807 proto.RegisterType((*ServiceReference)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ServiceReference")
808 proto.RegisterType((*ValidationRule)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ValidationRule")
809 proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.WebhookClientConfig")
810 }
811
812 func init() {
813 proto.RegisterFile("k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto", fileDescriptor_3623d6c0bd238430)
814 }
815
816 var fileDescriptor_3623d6c0bd238430 = []byte{
817
818 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5b, 0xcf, 0x73, 0x1c, 0x57,
819 0xf1, 0xf7, 0xac, 0xb4, 0xd2, 0xaa, 0x25, 0x5b, 0xd2, 0xb3, 0xa5, 0x8c, 0x15, 0x47, 0x2b, 0xaf,
820 0xbf, 0xf1, 0x57, 0x49, 0x9c, 0x55, 0xe2, 0x6f, 0xf2, 0x4d, 0x08, 0xa4, 0x52, 0x5a, 0x49, 0x0e,
821 0x4a, 0x2c, 0x4b, 0xbc, 0xb5, 0x1d, 0x41, 0x7e, 0x8e, 0x76, 0x9e, 0xd6, 0x63, 0xcf, 0xce, 0x8c,
822 0xe7, 0xcd, 0xac, 0xa4, 0x0a, 0x50, 0x40, 0x2a, 0x05, 0x45, 0x01, 0xa1, 0x48, 0x2e, 0x14, 0x70,
823 0x08, 0x14, 0x17, 0x0e, 0x70, 0x80, 0x1b, 0xfc, 0x01, 0x39, 0xa6, 0x80, 0x43, 0x0e, 0xd4, 0x16,
824 0x59, 0xfe, 0x05, 0x0a, 0xaa, 0x74, 0xa2, 0xde, 0x8f, 0x99, 0x79, 0x33, 0xbb, 0x6b, 0xbb, 0xa2,
825 0xdd, 0xb8, 0xb8, 0x69, 0xbb, 0xfb, 0xf5, 0xa7, 0xa7, 0x5f, 0xbf, 0xee, 0x7e, 0x3d, 0x23, 0xd8,
826 0xb8, 0xf5, 0x2c, 0x2d, 0x5b, 0xee, 0x92, 0xe1, 0x59, 0x64, 0x3f, 0x20, 0x0e, 0xb5, 0x5c, 0x87,
827 0x3e, 0x6e, 0x78, 0x16, 0x25, 0x7e, 0x93, 0xf8, 0x4b, 0xde, 0xad, 0x3a, 0xe3, 0xd1, 0xb4, 0xc0,
828 0x52, 0xf3, 0xc9, 0x1d, 0x12, 0x18, 0x4f, 0x2e, 0xd5, 0x89, 0x43, 0x7c, 0x23, 0x20, 0x66, 0xd9,
829 0xf3, 0xdd, 0xc0, 0x45, 0xcf, 0x0b, 0x75, 0xe5, 0x94, 0xf4, 0x9b, 0xb1, 0xba, 0xb2, 0x77, 0xab,
830 0xce, 0x78, 0x34, 0x2d, 0x50, 0x96, 0xea, 0xe6, 0x1e, 0xaf, 0x5b, 0xc1, 0x8d, 0x70, 0xa7, 0x5c,
831 0x73, 0x1b, 0x4b, 0x75, 0xb7, 0xee, 0x2e, 0x71, 0xad, 0x3b, 0xe1, 0x2e, 0xff, 0xc5, 0x7f, 0xf0,
832 0xbf, 0x04, 0xda, 0xdc, 0x53, 0x89, 0xf1, 0x0d, 0xa3, 0x76, 0xc3, 0x72, 0x88, 0x7f, 0x90, 0x58,
833 0xdc, 0x20, 0x81, 0xb1, 0xd4, 0xec, 0xb0, 0x71, 0x6e, 0xa9, 0xd7, 0x2a, 0x3f, 0x74, 0x02, 0xab,
834 0x41, 0x3a, 0x16, 0xfc, 0xff, 0xdd, 0x16, 0xd0, 0xda, 0x0d, 0xd2, 0x30, 0xb2, 0xeb, 0x4a, 0x87,
835 0x1a, 0x4c, 0xaf, 0xb8, 0x4e, 0x93, 0xf8, 0xec, 0x29, 0x31, 0xb9, 0x1d, 0x12, 0x1a, 0xa0, 0x0a,
836 0x0c, 0x85, 0x96, 0xa9, 0x6b, 0x0b, 0xda, 0xe2, 0x58, 0xe5, 0x89, 0x8f, 0x5a, 0xc5, 0x63, 0xed,
837 0x56, 0x71, 0xe8, 0xda, 0xfa, 0xea, 0x61, 0xab, 0x78, 0xb6, 0x17, 0x52, 0x70, 0xe0, 0x11, 0x5a,
838 0xbe, 0xb6, 0xbe, 0x8a, 0xd9, 0x62, 0xf4, 0x22, 0x4c, 0x9b, 0x84, 0x5a, 0x3e, 0x31, 0x97, 0xb7,
839 0xd6, 0xaf, 0x0b, 0xfd, 0x7a, 0x8e, 0x6b, 0x3c, 0x2d, 0x35, 0x4e, 0xaf, 0x66, 0x05, 0x70, 0xe7,
840 0x1a, 0xb4, 0x0d, 0xa3, 0xee, 0xce, 0x4d, 0x52, 0x0b, 0xa8, 0x3e, 0xb4, 0x30, 0xb4, 0x38, 0x7e,
841 0xf1, 0xf1, 0x72, 0xb2, 0x83, 0xb1, 0x09, 0x7c, 0xdb, 0xe4, 0xc3, 0x96, 0xb1, 0xb1, 0xb7, 0x16,
842 0xed, 0x5c, 0x65, 0x52, 0xa2, 0x8d, 0x6e, 0x0a, 0x2d, 0x38, 0x52, 0x57, 0xfa, 0x55, 0x0e, 0x90,
843 0xfa, 0xf0, 0xd4, 0x73, 0x1d, 0x4a, 0xfa, 0xf2, 0xf4, 0x14, 0xa6, 0x6a, 0x5c, 0x73, 0x40, 0x4c,
844 0x89, 0xab, 0xe7, 0x3e, 0x8b, 0xf5, 0xba, 0xc4, 0x9f, 0x5a, 0xc9, 0xa8, 0xc3, 0x1d, 0x00, 0xe8,
845 0x2a, 0x8c, 0xf8, 0x84, 0x86, 0x76, 0xa0, 0x0f, 0x2d, 0x68, 0x8b, 0xe3, 0x17, 0x2f, 0xf4, 0x84,
846 0xe2, 0xf1, 0xcd, 0x82, 0xaf, 0xdc, 0x7c, 0xb2, 0x5c, 0x0d, 0x8c, 0x20, 0xa4, 0x95, 0x13, 0x12,
847 0x69, 0x04, 0x73, 0x1d, 0x58, 0xea, 0x2a, 0x7d, 0x2f, 0x07, 0x53, 0xaa, 0x97, 0x9a, 0x16, 0xd9,
848 0x43, 0x7b, 0x30, 0xea, 0x8b, 0x60, 0xe1, 0x7e, 0x1a, 0xbf, 0xb8, 0x55, 0x3e, 0xd2, 0xb1, 0x2a,
849 0x77, 0x04, 0x61, 0x65, 0x9c, 0xed, 0x99, 0xfc, 0x81, 0x23, 0x34, 0xf4, 0x36, 0x14, 0x7c, 0xb9,
850 0x51, 0x3c, 0x9a, 0xc6, 0x2f, 0x7e, 0xa5, 0x8f, 0xc8, 0x42, 0x71, 0x65, 0xa2, 0xdd, 0x2a, 0x16,
851 0xa2, 0x5f, 0x38, 0x06, 0x2c, 0xbd, 0x9f, 0x83, 0xf9, 0x95, 0x90, 0x06, 0x6e, 0x03, 0x13, 0xea,
852 0x86, 0x7e, 0x8d, 0xac, 0xb8, 0x76, 0xd8, 0x70, 0x56, 0xc9, 0xae, 0xe5, 0x58, 0x01, 0x8b, 0xd6,
853 0x05, 0x18, 0x76, 0x8c, 0x06, 0x91, 0xd1, 0x33, 0x21, 0x7d, 0x3a, 0x7c, 0xc5, 0x68, 0x10, 0xcc,
854 0x39, 0x4c, 0x82, 0x05, 0x8b, 0x3c, 0x0b, 0xb1, 0xc4, 0xd5, 0x03, 0x8f, 0x60, 0xce, 0x41, 0xe7,
855 0x61, 0x64, 0xd7, 0xf5, 0x1b, 0x86, 0xd8, 0xc7, 0xb1, 0x64, 0x67, 0x2e, 0x71, 0x2a, 0x96, 0x5c,
856 0xf4, 0x34, 0x8c, 0x9b, 0x84, 0xd6, 0x7c, 0xcb, 0x63, 0xd0, 0xfa, 0x30, 0x17, 0x3e, 0x29, 0x85,
857 0xc7, 0x57, 0x13, 0x16, 0x56, 0xe5, 0xd0, 0x05, 0x28, 0x78, 0xbe, 0xe5, 0xfa, 0x56, 0x70, 0xa0,
858 0xe7, 0x17, 0xb4, 0xc5, 0x7c, 0x65, 0x4a, 0xae, 0x29, 0x6c, 0x49, 0x3a, 0x8e, 0x25, 0xd0, 0x02,
859 0x14, 0x5e, 0xaa, 0x6e, 0x5e, 0xd9, 0x32, 0x82, 0x1b, 0xfa, 0x08, 0x47, 0x18, 0x66, 0xd2, 0x38,
860 0xa6, 0x96, 0xfe, 0x96, 0x03, 0x3d, 0xeb, 0x95, 0xc8, 0xa5, 0xe8, 0x12, 0x14, 0x68, 0xc0, 0x32,
861 0x4e, 0xfd, 0x40, 0xfa, 0xe4, 0xd1, 0x08, 0xac, 0x2a, 0xe9, 0x87, 0xad, 0xe2, 0x6c, 0xb2, 0x22,
862 0xa2, 0x72, 0x7f, 0xc4, 0x6b, 0xd1, 0x2f, 0x34, 0x38, 0xb9, 0x47, 0x76, 0x6e, 0xb8, 0xee, 0xad,
863 0x15, 0xdb, 0x22, 0x4e, 0xb0, 0xe2, 0x3a, 0xbb, 0x56, 0x5d, 0xc6, 0x00, 0x3e, 0x62, 0x0c, 0xbc,
864 0xd2, 0xa9, 0xb9, 0xf2, 0x40, 0xbb, 0x55, 0x3c, 0xd9, 0x85, 0x81, 0xbb, 0xd9, 0x81, 0xb6, 0x41,
865 0xaf, 0x65, 0x0e, 0x89, 0x4c, 0x60, 0x22, 0x6d, 0x8d, 0x55, 0xce, 0xb4, 0x5b, 0x45, 0x7d, 0xa5,
866 0x87, 0x0c, 0xee, 0xb9, 0xba, 0xf4, 0xce, 0x50, 0xd6, 0xbd, 0x4a, 0xb8, 0xbd, 0x05, 0x05, 0x76,
867 0x8c, 0x4d, 0x23, 0x30, 0xe4, 0x41, 0x7c, 0xe2, 0xde, 0x0e, 0xbd, 0xc8, 0x19, 0x1b, 0x24, 0x30,
868 0x2a, 0x48, 0x6e, 0x08, 0x24, 0x34, 0x1c, 0x6b, 0x45, 0xdf, 0x80, 0x61, 0xea, 0x91, 0x9a, 0x74,
869 0xf4, 0xab, 0x47, 0x3d, 0x6c, 0x3d, 0x1e, 0xa4, 0xea, 0x91, 0x5a, 0x72, 0x16, 0xd8, 0x2f, 0xcc,
870 0x61, 0xd1, 0xbb, 0x1a, 0x8c, 0x50, 0x9e, 0xa0, 0x64, 0x52, 0x7b, 0x7d, 0x50, 0x16, 0x64, 0xb2,
871 0xa0, 0xf8, 0x8d, 0x25, 0x78, 0xe9, 0x9f, 0x39, 0x38, 0xdb, 0x6b, 0xe9, 0x8a, 0xeb, 0x98, 0x62,
872 0x3b, 0xd6, 0xe5, 0xd9, 0x16, 0x91, 0xfe, 0xb4, 0x7a, 0xb6, 0x0f, 0x5b, 0xc5, 0x87, 0xef, 0xaa,
873 0x40, 0x49, 0x02, 0x5f, 0x88, 0x9f, 0x5b, 0x24, 0x8a, 0xb3, 0x69, 0xc3, 0x0e, 0x5b, 0xc5, 0xc9,
874 0x78, 0x59, 0xda, 0x56, 0xd4, 0x04, 0x64, 0x1b, 0x34, 0xb8, 0xea, 0x1b, 0x0e, 0x15, 0x6a, 0xad,
875 0x06, 0x91, 0xee, 0x7b, 0xf4, 0xde, 0xc2, 0x83, 0xad, 0xa8, 0xcc, 0x49, 0x48, 0x74, 0xb9, 0x43,
876 0x1b, 0xee, 0x82, 0xc0, 0xf2, 0x96, 0x4f, 0x0c, 0x1a, 0xa7, 0x22, 0xa5, 0xa2, 0x30, 0x2a, 0x96,
877 0x5c, 0xf4, 0x08, 0x8c, 0x36, 0x08, 0xa5, 0x46, 0x9d, 0xf0, 0xfc, 0x33, 0x96, 0x94, 0xe8, 0x0d,
878 0x41, 0xc6, 0x11, 0x9f, 0xf5, 0x27, 0x67, 0x7a, 0x79, 0xed, 0xb2, 0x45, 0x03, 0xf4, 0x5a, 0xc7,
879 0x01, 0x28, 0xdf, 0xdb, 0x13, 0xb2, 0xd5, 0x3c, 0xfc, 0xe3, 0xe4, 0x17, 0x51, 0x94, 0xe0, 0xff,
880 0x3a, 0xe4, 0xad, 0x80, 0x34, 0xa2, 0xda, 0xfd, 0xca, 0x80, 0x62, 0xaf, 0x72, 0x5c, 0xda, 0x90,
881 0x5f, 0x67, 0x68, 0x58, 0x80, 0x96, 0x7e, 0x9d, 0x83, 0x87, 0x7a, 0x2d, 0x61, 0x05, 0x85, 0x32,
882 0x8f, 0x7b, 0x76, 0xe8, 0x1b, 0xb6, 0x8c, 0xb8, 0xd8, 0xe3, 0x5b, 0x9c, 0x8a, 0x25, 0x97, 0xa5,
883 0x7c, 0x6a, 0x39, 0xf5, 0xd0, 0x36, 0x7c, 0x19, 0x4e, 0xf1, 0x53, 0x57, 0x25, 0x1d, 0xc7, 0x12,
884 0xa8, 0x0c, 0x40, 0x6f, 0xb8, 0x7e, 0xc0, 0x31, 0x64, 0xf6, 0x3a, 0xc1, 0x12, 0x44, 0x35, 0xa6,
885 0x62, 0x45, 0x82, 0x55, 0xb4, 0x5b, 0x96, 0x63, 0xca, 0x5d, 0x8f, 0x4f, 0xf1, 0xcb, 0x96, 0x63,
886 0x62, 0xce, 0x61, 0xf8, 0xb6, 0x45, 0x03, 0x46, 0x91, 0x5b, 0x9e, 0xf2, 0x3a, 0x97, 0x8c, 0x25,
887 0x18, 0x7e, 0x8d, 0x65, 0x7d, 0xd7, 0xb7, 0x08, 0xd5, 0x47, 0x12, 0xfc, 0x95, 0x98, 0x8a, 0x15,
888 0x89, 0xd2, 0x3b, 0xd0, 0x3b, 0x48, 0x58, 0x2a, 0x41, 0xe7, 0x20, 0x5f, 0xf7, 0xdd, 0xd0, 0x93,
889 0x5e, 0x8a, 0xbd, 0xfd, 0x22, 0x23, 0x62, 0xc1, 0x63, 0x51, 0xd9, 0x4c, 0xb5, 0xa9, 0x71, 0x54,
890 0x46, 0xcd, 0x69, 0xc4, 0x47, 0xdf, 0xd6, 0x20, 0xef, 0x48, 0xe7, 0xb0, 0x90, 0x7b, 0x6d, 0x40,
891 0x71, 0xc1, 0xdd, 0x9b, 0x98, 0x2b, 0x3c, 0x2f, 0x90, 0xd1, 0x53, 0x90, 0xa7, 0x35, 0xd7, 0x23,
892 0xd2, 0xeb, 0xf3, 0x91, 0x50, 0x95, 0x11, 0x0f, 0x5b, 0xc5, 0xe3, 0x91, 0x3a, 0x4e, 0xc0, 0x42,
893 0x18, 0x7d, 0x57, 0x03, 0x68, 0x1a, 0xb6, 0x65, 0x1a, 0xbc, 0x65, 0xc8, 0x73, 0xf3, 0xfb, 0x1b,
894 0xd6, 0xd7, 0x63, 0xf5, 0x62, 0xd3, 0x92, 0xdf, 0x58, 0x81, 0x46, 0xef, 0x69, 0x30, 0x41, 0xc3,
895 0x1d, 0x5f, 0xae, 0xa2, 0xbc, 0xb9, 0x18, 0xbf, 0xf8, 0xd5, 0xbe, 0xda, 0x52, 0x55, 0x00, 0x2a,
896 0x53, 0xed, 0x56, 0x71, 0x42, 0xa5, 0xe0, 0x94, 0x01, 0xe8, 0x07, 0x1a, 0x14, 0x9a, 0x51, 0xcd,
897 0x1e, 0xe5, 0x07, 0xfe, 0x8d, 0x01, 0x6d, 0xac, 0x8c, 0xa8, 0xe4, 0x14, 0xc4, 0x7d, 0x40, 0x6c,
898 0x01, 0xfa, 0xa3, 0x06, 0xba, 0x61, 0x8a, 0x04, 0x6f, 0xd8, 0x5b, 0xbe, 0xe5, 0x04, 0xc4, 0x17,
899 0xfd, 0x26, 0xd5, 0x0b, 0xdc, 0xbc, 0xfe, 0xd6, 0xc2, 0x6c, 0x2f, 0x5b, 0x59, 0x90, 0xd6, 0xe9,
900 0xcb, 0x3d, 0xcc, 0xc0, 0x3d, 0x0d, 0x44, 0x1f, 0x68, 0x30, 0x45, 0x89, 0x4d, 0x6a, 0x81, 0xb1,
901 0x63, 0x93, 0x4b, 0x16, 0xb1, 0x4d, 0xaa, 0x8f, 0x73, 0xab, 0xaf, 0x1c, 0xd1, 0xea, 0x6a, 0x5a,
902 0x6d, 0x72, 0x45, 0xca, 0x30, 0x28, 0xee, 0xb0, 0x80, 0xc7, 0x7f, 0xd2, 0x69, 0xe9, 0x63, 0x03,
903 0x88, 0xff, 0xa4, 0xc5, 0x93, 0x49, 0x2b, 0x69, 0xec, 0x14, 0x68, 0xb4, 0x09, 0x33, 0x9e, 0x4f,
904 0x38, 0xc0, 0x35, 0xe7, 0x96, 0xe3, 0xee, 0x39, 0xd2, 0x49, 0xb0, 0xa0, 0x2d, 0x16, 0x2a, 0xa7,
905 0xdb, 0xad, 0xe2, 0xcc, 0x56, 0x37, 0x01, 0xdc, 0x7d, 0x5d, 0xe9, 0xbd, 0xa1, 0xec, 0xe5, 0x24,
906 0xdb, 0xdc, 0xb0, 0x4d, 0x61, 0x26, 0x88, 0x2d, 0xa3, 0xba, 0xc6, 0xb7, 0xe3, 0xad, 0x01, 0xc5,
907 0x78, 0xdc, 0x9d, 0x24, 0x0d, 0x66, 0x4c, 0xa2, 0x58, 0xb1, 0x03, 0xfd, 0x54, 0x83, 0xe3, 0x46,
908 0xad, 0x46, 0xbc, 0x80, 0x98, 0xa2, 0xe6, 0xe4, 0x3e, 0x87, 0xb4, 0x3a, 0x23, 0xad, 0x3a, 0xbe,
909 0xac, 0x42, 0xe3, 0xb4, 0x25, 0xe8, 0x39, 0x38, 0x41, 0x03, 0xd7, 0x27, 0x66, 0xa6, 0x9b, 0x47,
910 0xed, 0x56, 0xf1, 0x44, 0x35, 0xc5, 0xc1, 0x19, 0xc9, 0xd2, 0xbf, 0x46, 0xa0, 0x78, 0x97, 0x0c,
911 0x70, 0x0f, 0xf7, 0xc5, 0xf3, 0x30, 0xc2, 0x1f, 0xd7, 0xe4, 0x5e, 0x29, 0x28, 0x1d, 0x2a, 0xa7,
912 0x62, 0xc9, 0x65, 0xf5, 0x8b, 0xe1, 0xb3, 0xae, 0x6a, 0x88, 0x0b, 0xc6, 0xf5, 0xab, 0x2a, 0xc8,
913 0x38, 0xe2, 0xa3, 0x8b, 0x00, 0x26, 0xf1, 0x7c, 0xc2, 0x6a, 0xa8, 0xa9, 0x8f, 0x72, 0xe9, 0x78,
914 0x93, 0x56, 0x63, 0x0e, 0x56, 0xa4, 0xd0, 0x25, 0x40, 0xd1, 0x2f, 0xcb, 0x75, 0x5e, 0x31, 0x7c,
915 0xc7, 0x72, 0xea, 0x7a, 0x81, 0x9b, 0x3d, 0xcb, 0x9a, 0xc4, 0xd5, 0x0e, 0x2e, 0xee, 0xb2, 0x02,
916 0xbd, 0x0d, 0x23, 0x62, 0x16, 0xc5, 0x0b, 0xd7, 0x00, 0x8b, 0x0f, 0x70, 0x1f, 0x71, 0x28, 0x2c,
917 0x21, 0x3b, 0x8b, 0x4e, 0xfe, 0x7e, 0x17, 0x9d, 0x3b, 0x66, 0xf9, 0x91, 0xff, 0xca, 0x2c, 0x3f,
918 0x76, 0xbf, 0xb3, 0x7c, 0xe9, 0xdf, 0x5a, 0x36, 0x15, 0x2a, 0x3b, 0x50, 0xad, 0x19, 0x36, 0x41,
919 0xab, 0x30, 0xc5, 0xee, 0x97, 0x98, 0x78, 0xb6, 0x55, 0x33, 0x28, 0x1f, 0x6f, 0x88, 0x33, 0x98,
920 0x00, 0x65, 0xf8, 0xb8, 0x63, 0x05, 0x7a, 0x09, 0x90, 0xb8, 0x73, 0xa5, 0xf4, 0x88, 0xf6, 0x31,
921 0xbe, 0x3d, 0x55, 0x3b, 0x24, 0x70, 0x97, 0x55, 0x68, 0x05, 0xa6, 0x6d, 0x63, 0x87, 0xd8, 0xe2,
922 0xf9, 0x5c, 0x9f, 0xab, 0x12, 0x03, 0xa0, 0x99, 0x76, 0xab, 0x38, 0x7d, 0x39, 0xcb, 0xc4, 0x9d,
923 0xf2, 0xa5, 0xb3, 0xd9, 0x8c, 0xa3, 0x3e, 0xb8, 0xb8, 0xc9, 0x7e, 0x98, 0x83, 0xb9, 0xde, 0x01,
924 0x8b, 0xbe, 0x93, 0x5c, 0xb8, 0xc5, 0x7d, 0xea, 0x8d, 0x41, 0x1d, 0x0e, 0x79, 0xe3, 0x86, 0xce,
925 0xdb, 0x36, 0xfa, 0x26, 0x6b, 0x6e, 0x0d, 0x3b, 0x1a, 0xf1, 0xbd, 0x3e, 0x30, 0x13, 0x18, 0x48,
926 0x65, 0x4c, 0xf4, 0xcd, 0x86, 0xcd, 0xdb, 0x64, 0xc3, 0x26, 0xa5, 0xdf, 0x68, 0xd9, 0x99, 0x4b,
927 0x92, 0x58, 0xd0, 0x0f, 0x35, 0x98, 0x74, 0x3d, 0xe2, 0x2c, 0x6f, 0xad, 0x5f, 0xff, 0x3f, 0x91,
928 0x60, 0xa4, 0xab, 0x8e, 0x1a, 0xf3, 0x2f, 0x55, 0x37, 0xaf, 0x08, 0x85, 0x5b, 0xbe, 0xeb, 0xd1,
929 0xca, 0xc9, 0x76, 0xab, 0x38, 0xb9, 0x99, 0x86, 0xc2, 0x59, 0xec, 0x52, 0x03, 0x66, 0xd6, 0xf6,
930 0x03, 0xe2, 0x3b, 0x86, 0xbd, 0xea, 0xd6, 0xc2, 0x06, 0x71, 0x02, 0x61, 0x68, 0x66, 0x3e, 0xa8,
931 0xdd, 0xe3, 0x7c, 0xf0, 0x21, 0x18, 0x0a, 0x7d, 0x5b, 0x46, 0xf1, 0x78, 0x3c, 0xff, 0xc6, 0x97,
932 0x31, 0xa3, 0x97, 0xce, 0xc2, 0x30, 0xb3, 0x13, 0x9d, 0x86, 0x21, 0xdf, 0xd8, 0xe3, 0x5a, 0x27,
933 0x2a, 0xa3, 0x4c, 0x04, 0x1b, 0x7b, 0x98, 0xd1, 0x4a, 0x7f, 0x3d, 0x0b, 0x93, 0x99, 0x67, 0x41,
934 0x73, 0x90, 0x8b, 0x87, 0xea, 0x20, 0x95, 0xe6, 0xd6, 0x57, 0x71, 0xce, 0x32, 0xd1, 0x33, 0x71,
935 0x4d, 0x10, 0xa0, 0xc5, 0xb8, 0xc4, 0x71, 0x2a, 0xbb, 0xcd, 0x24, 0xea, 0x98, 0x21, 0x51, 0x3e,
936 0x67, 0x36, 0x90, 0x5d, 0x79, 0x4a, 0x84, 0x0d, 0x64, 0x17, 0x33, 0xda, 0x67, 0x1d, 0x8e, 0x46,
937 0xd3, 0xd9, 0xfc, 0x3d, 0x4c, 0x67, 0x47, 0xee, 0x38, 0x9d, 0x3d, 0x07, 0xf9, 0xc0, 0x0a, 0x6c,
938 0xc2, 0xeb, 0xab, 0x72, 0xe9, 0xbc, 0xca, 0x88, 0x58, 0xf0, 0xd0, 0x4d, 0x18, 0x35, 0xc9, 0xae,
939 0x11, 0xda, 0x01, 0x2f, 0xa5, 0xe3, 0x17, 0x57, 0xfa, 0x10, 0x42, 0x62, 0x74, 0xbe, 0x2a, 0xf4,
940 0xe2, 0x08, 0x00, 0x3d, 0x0c, 0xa3, 0x0d, 0x63, 0xdf, 0x6a, 0x84, 0x0d, 0xde, 0xf7, 0x6a, 0x42,
941 0x6c, 0x43, 0x90, 0x70, 0xc4, 0x63, 0x99, 0x91, 0xec, 0xd7, 0xec, 0x90, 0x5a, 0x4d, 0x22, 0x99,
942 0xb2, 0x27, 0x8d, 0x33, 0xe3, 0x5a, 0x86, 0x8f, 0x3b, 0x56, 0x70, 0x30, 0xcb, 0xe1, 0x8b, 0xc7,
943 0x15, 0x30, 0x41, 0xc2, 0x11, 0x2f, 0x0d, 0x26, 0xe5, 0x27, 0x7a, 0x81, 0xc9, 0xc5, 0x1d, 0x2b,
944 0xd0, 0x63, 0x30, 0xd6, 0x30, 0xf6, 0x2f, 0x13, 0xa7, 0x1e, 0xdc, 0xd0, 0x8f, 0x2f, 0x68, 0x8b,
945 0x43, 0x95, 0xe3, 0xed, 0x56, 0x71, 0x6c, 0x23, 0x22, 0xe2, 0x84, 0xcf, 0x85, 0x2d, 0x47, 0x0a,
946 0x9f, 0x50, 0x84, 0x23, 0x22, 0x4e, 0xf8, 0xac, 0xa9, 0xf2, 0x8c, 0x80, 0x1d, 0x2e, 0x7d, 0x32,
947 0x3d, 0x14, 0xd8, 0x12, 0x64, 0x1c, 0xf1, 0xd1, 0x22, 0x14, 0x1a, 0xc6, 0x3e, 0x1f, 0xe0, 0xe8,
948 0x53, 0x5c, 0x2d, 0x7f, 0x8d, 0xb0, 0x21, 0x69, 0x38, 0xe6, 0x72, 0x49, 0xcb, 0x11, 0x92, 0xd3,
949 0x8a, 0xa4, 0xa4, 0xe1, 0x98, 0xcb, 0x82, 0x38, 0x74, 0xac, 0xdb, 0x21, 0x11, 0xc2, 0x88, 0x7b,
950 0x26, 0x0e, 0xe2, 0x6b, 0x09, 0x0b, 0xab, 0x72, 0xa8, 0x0c, 0xd0, 0x08, 0xed, 0xc0, 0xf2, 0x6c,
951 0xb2, 0xb9, 0xab, 0x9f, 0xe4, 0xfe, 0xe7, 0x77, 0x91, 0x8d, 0x98, 0x8a, 0x15, 0x09, 0x44, 0x60,
952 0x98, 0x38, 0x61, 0x43, 0x3f, 0xc5, 0x2b, 0x77, 0x5f, 0x42, 0x30, 0x3e, 0x39, 0x6b, 0x4e, 0xd8,
953 0xc0, 0x5c, 0x3d, 0x7a, 0x06, 0x8e, 0x37, 0x8c, 0x7d, 0x96, 0x0e, 0x88, 0x1f, 0x58, 0x84, 0xea,
954 0x33, 0xfc, 0xe1, 0xa7, 0x59, 0x13, 0xbe, 0xa1, 0x32, 0x70, 0x5a, 0x8e, 0x2f, 0xb4, 0x1c, 0x65,
955 0xe1, 0xac, 0xb2, 0x50, 0x65, 0xe0, 0xb4, 0x1c, 0xf3, 0xb4, 0x4f, 0x6e, 0x87, 0x96, 0x4f, 0x4c,
956 0xfd, 0x01, 0xde, 0xb7, 0xcb, 0x57, 0x3b, 0x82, 0x86, 0x63, 0x2e, 0x6a, 0x46, 0x93, 0x3e, 0x9d,
957 0x1f, 0xc3, 0x6b, 0xfd, 0xcd, 0xe4, 0x9b, 0xfe, 0xb2, 0xef, 0x1b, 0x07, 0xa2, 0xd2, 0xa8, 0x33,
958 0x3e, 0x44, 0x21, 0x6f, 0xd8, 0xf6, 0xe6, 0xae, 0x7e, 0xba, 0x2f, 0x5d, 0x53, 0xb6, 0x82, 0xc4,
959 0x59, 0x67, 0x99, 0x81, 0x60, 0x81, 0xc5, 0x40, 0x5d, 0x87, 0x85, 0xc6, 0xdc, 0x60, 0x41, 0x37,
960 0x19, 0x08, 0x16, 0x58, 0xfc, 0x49, 0x9d, 0x83, 0xcd, 0x5d, 0xfd, 0xc1, 0x01, 0x3f, 0x29, 0x03,
961 0xc1, 0x02, 0x0b, 0x59, 0x30, 0xe4, 0xb8, 0x81, 0x7e, 0x66, 0x20, 0xe5, 0x99, 0x17, 0x9c, 0x2b,
962 0x6e, 0x80, 0x19, 0x06, 0xfa, 0x89, 0x06, 0xe0, 0x25, 0x21, 0xfa, 0x50, 0x5f, 0x06, 0x48, 0x19,
963 0xc8, 0x72, 0x12, 0xdb, 0x6b, 0x4e, 0xe0, 0x1f, 0x24, 0xb7, 0x36, 0xe5, 0x0c, 0x28, 0x56, 0xa0,
964 0x5f, 0x6a, 0x70, 0x4a, 0xed, 0xde, 0x63, 0xf3, 0xe6, 0xb9, 0x47, 0xae, 0xf6, 0x3b, 0xcc, 0x2b,
965 0xae, 0x6b, 0x57, 0xf4, 0x76, 0xab, 0x78, 0x6a, 0xb9, 0x0b, 0x2a, 0xee, 0x6a, 0x0b, 0xfa, 0xad,
966 0x06, 0xd3, 0x32, 0x8b, 0x2a, 0x16, 0x16, 0xb9, 0x03, 0x49, 0xbf, 0x1d, 0x98, 0xc5, 0x11, 0x7e,
967 0x8c, 0x3f, 0x49, 0xe8, 0xe0, 0xe3, 0x4e, 0xd3, 0xd0, 0x1f, 0x34, 0x98, 0x30, 0x89, 0x47, 0x1c,
968 0x93, 0x38, 0x35, 0x66, 0xeb, 0x42, 0x5f, 0x26, 0x29, 0x59, 0x5b, 0x57, 0x15, 0x08, 0x61, 0x66,
969 0x59, 0x9a, 0x39, 0xa1, 0xb2, 0x0e, 0x5b, 0xc5, 0xd9, 0x64, 0xa9, 0xca, 0xc1, 0x29, 0x2b, 0xd1,
970 0xfb, 0x1a, 0x4c, 0x26, 0x1b, 0x20, 0x4a, 0xca, 0xd9, 0x01, 0xc6, 0x01, 0x6f, 0x5f, 0x97, 0xd3,
971 0x80, 0x38, 0x6b, 0x01, 0xfa, 0x9d, 0xc6, 0x3a, 0xb5, 0xe8, 0x3a, 0x4a, 0xf5, 0x12, 0xf7, 0xe5,
972 0x9b, 0x7d, 0xf7, 0x65, 0x8c, 0x20, 0x5c, 0x79, 0x21, 0x69, 0x05, 0x63, 0xce, 0x61, 0xab, 0x38,
973 0xa3, 0x7a, 0x32, 0x66, 0x60, 0xd5, 0x42, 0xf4, 0x7d, 0x0d, 0x26, 0x48, 0xd2, 0x71, 0x53, 0xfd,
974 0x5c, 0x5f, 0x9c, 0xd8, 0xb5, 0x89, 0x17, 0x03, 0x04, 0x85, 0x45, 0x71, 0x0a, 0x9b, 0x75, 0x90,
975 0x64, 0xdf, 0x68, 0x78, 0x36, 0xd1, 0xff, 0xa7, 0xcf, 0x1d, 0xe4, 0x9a, 0xd0, 0x8b, 0x23, 0x00,
976 0x74, 0x01, 0x0a, 0x4e, 0x68, 0xdb, 0xec, 0xa6, 0xad, 0x3f, 0xcc, 0x7b, 0x91, 0x78, 0x80, 0x7d,
977 0x45, 0xd2, 0x71, 0x2c, 0x81, 0x76, 0x61, 0x61, 0xff, 0xe5, 0x70, 0x87, 0xf8, 0x0e, 0x09, 0x08,
978 0xed, 0x3a, 0xcb, 0xd4, 0xcf, 0x73, 0x2d, 0x73, 0xed, 0x56, 0x71, 0x76, 0xbb, 0xfb, 0xb4, 0xf3,
979 0xae, 0x3a, 0xd0, 0xab, 0xf0, 0xa0, 0x22, 0xb3, 0xd6, 0xd8, 0x21, 0xa6, 0x49, 0xcc, 0xe8, 0xe2,
980 0xa6, 0xff, 0xaf, 0x98, 0xa7, 0x46, 0x07, 0x7c, 0x3b, 0x2b, 0x80, 0xef, 0xb4, 0x1a, 0x5d, 0x86,
981 0x59, 0x85, 0xbd, 0xee, 0x04, 0x9b, 0x7e, 0x35, 0xf0, 0x2d, 0xa7, 0xae, 0x2f, 0x72, 0xbd, 0xa7,
982 0xa2, 0x13, 0xb9, 0xad, 0xf0, 0x70, 0x8f, 0x35, 0xe8, 0xcb, 0x29, 0x6d, 0xfc, 0x85, 0xa3, 0xe1,
983 0xbd, 0x4c, 0x0e, 0xa8, 0xfe, 0x08, 0xef, 0x4e, 0xf8, 0x66, 0x6f, 0x2b, 0x74, 0xdc, 0x43, 0x1e,
984 0xbd, 0x00, 0x27, 0x33, 0x1c, 0x76, 0x45, 0xd1, 0x1f, 0x15, 0x77, 0x0d, 0xd6, 0xcf, 0x6e, 0x47,
985 0x44, 0xdc, 0x4d, 0x12, 0x7d, 0x09, 0x90, 0x42, 0xde, 0x30, 0x3c, 0xbe, 0xfe, 0x31, 0x71, 0xed,
986 0x61, 0x3b, 0xba, 0x2d, 0x69, 0xb8, 0x8b, 0x1c, 0xfa, 0x99, 0x96, 0x7a, 0x92, 0xe4, 0x76, 0x4c,
987 0xf5, 0x0b, 0xfc, 0xfc, 0x6e, 0x1c, 0x31, 0x0a, 0x95, 0xb7, 0x46, 0xa1, 0x4d, 0x14, 0x37, 0x2b,
988 0x50, 0xb8, 0x87, 0x09, 0x73, 0xec, 0x86, 0x9e, 0xc9, 0xf0, 0x68, 0x0a, 0x86, 0x6e, 0x11, 0xf9,
989 0x0d, 0x0a, 0x66, 0x7f, 0x22, 0x13, 0xf2, 0x4d, 0xc3, 0x0e, 0xa3, 0x21, 0x43, 0x9f, 0xbb, 0x03,
990 0x2c, 0x94, 0x3f, 0x97, 0x7b, 0x56, 0x9b, 0xfb, 0x40, 0x83, 0xd9, 0xee, 0x85, 0xe7, 0xbe, 0x9a,
991 0xf5, 0x73, 0x0d, 0xa6, 0x3b, 0x6a, 0x4c, 0x17, 0x8b, 0x6e, 0xa7, 0x2d, 0x7a, 0xb5, 0xdf, 0xc5,
992 0x42, 0x1c, 0x0e, 0xde, 0x21, 0xab, 0xe6, 0xfd, 0x48, 0x83, 0xa9, 0x6c, 0xda, 0xbe, 0x9f, 0xfe,
993 0x2a, 0x7d, 0x90, 0x83, 0xd9, 0xee, 0x8d, 0x3d, 0xf2, 0xe3, 0x09, 0xc6, 0x60, 0x26, 0x41, 0xdd,
994 0x86, 0xd9, 0xef, 0x6a, 0x30, 0x7e, 0x33, 0x96, 0x8b, 0xbe, 0x51, 0xe8, 0xfb, 0x0c, 0x2a, 0xaa,
995 0x93, 0x09, 0x83, 0x62, 0x15, 0xb7, 0xf4, 0x7b, 0x0d, 0x66, 0xba, 0x36, 0x00, 0xe8, 0x3c, 0x8c,
996 0x18, 0xb6, 0xed, 0xee, 0x89, 0x51, 0xa2, 0xf2, 0xea, 0x62, 0x99, 0x53, 0xb1, 0xe4, 0x2a, 0xde,
997 0xcb, 0x7d, 0x5e, 0xde, 0x2b, 0xfd, 0x49, 0x83, 0x33, 0x77, 0x8a, 0xc4, 0xfb, 0xb2, 0xa5, 0x8b,
998 0x50, 0x90, 0xcd, 0xfb, 0x01, 0xdf, 0x4e, 0x99, 0x8a, 0x65, 0xd2, 0xe0, 0x9f, 0xe5, 0x89, 0xbf,
999 0x4a, 0x2f, 0xc0, 0x64, 0x66, 0x10, 0xce, 0xaa, 0xf3, 0x4d, 0xea, 0x3a, 0xca, 0x28, 0x3b, 0xae,
1000 0xce, 0xd1, 0xb7, 0x7a, 0x38, 0x96, 0x28, 0x7d, 0xa8, 0xc1, 0x54, 0x95, 0xf8, 0x4d, 0xab, 0x46,
1001 0x30, 0xd9, 0x25, 0x3e, 0x71, 0x6a, 0x04, 0x2d, 0xc1, 0x18, 0xff, 0xba, 0xc0, 0x33, 0x6a, 0xd1,
1002 0x2b, 0xa9, 0x69, 0xa9, 0x63, 0xec, 0x4a, 0xc4, 0xc0, 0x89, 0x4c, 0xfc, 0xfa, 0x2a, 0xd7, 0xf3,
1003 0xf5, 0xd5, 0x19, 0x18, 0xf6, 0x92, 0x49, 0x76, 0x81, 0x71, 0xb9, 0x25, 0x9c, 0xca, 0xb9, 0xae,
1004 0x1f, 0xf0, 0xf1, 0x5c, 0x5e, 0x72, 0x5d, 0x3f, 0xc0, 0x9c, 0x5a, 0xfa, 0x4b, 0x0e, 0x4e, 0xa4,
1005 0x0b, 0x01, 0x03, 0xf4, 0x43, 0xbb, 0xe3, 0x7d, 0x19, 0xe3, 0x61, 0xce, 0x51, 0xbf, 0x2e, 0xca,
1006 0xdd, 0xf9, 0xeb, 0x22, 0xf4, 0x22, 0x4c, 0xcb, 0x3f, 0xd7, 0xf6, 0x3d, 0x9f, 0x50, 0xfe, 0x4e,
1007 0x78, 0x28, 0xfd, 0x8d, 0xf2, 0x46, 0x56, 0x00, 0x77, 0xae, 0x41, 0x5f, 0xcc, 0x7c, 0xf9, 0x74,
1008 0x2e, 0xf9, 0xea, 0x89, 0xf5, 0x94, 0x7c, 0x7f, 0xae, 0xb3, 0x3c, 0xb2, 0xe6, 0xfb, 0xae, 0x9f,
1009 0xf9, 0x1c, 0x6a, 0x09, 0xc6, 0x76, 0x99, 0x00, 0xdf, 0xb8, 0x7c, 0xda, 0xe9, 0x97, 0x22, 0x06,
1010 0x4e, 0x64, 0xd0, 0xf3, 0x30, 0xe9, 0x7a, 0xa2, 0x85, 0xde, 0xb4, 0xcd, 0x2a, 0xb1, 0x77, 0xf9,
1011 0x28, 0xb2, 0x10, 0xcd, 0x8b, 0x53, 0x2c, 0x9c, 0x95, 0x2d, 0xfd, 0x59, 0x83, 0x6e, 0xdf, 0x35,
1012 0xa2, 0xd3, 0x62, 0xee, 0xab, 0x0c, 0x53, 0xa3, 0x99, 0x2f, 0x6a, 0xc2, 0x28, 0x15, 0xb1, 0x22,
1013 0x0f, 0xc3, 0xe6, 0x91, 0xdf, 0xee, 0xa4, 0x23, 0x4f, 0x34, 0x9c, 0x11, 0x35, 0x02, 0x63, 0xe7,
1014 0xa1, 0x66, 0x54, 0x42, 0xc7, 0x94, 0xaf, 0x02, 0x26, 0xc4, 0x79, 0x58, 0x59, 0x16, 0x34, 0x1c,
1015 0x73, 0x2b, 0xb5, 0x8f, 0x3e, 0x9d, 0x3f, 0xf6, 0xf1, 0xa7, 0xf3, 0xc7, 0x3e, 0xf9, 0x74, 0xfe,
1016 0xd8, 0xb7, 0xda, 0xf3, 0xda, 0x47, 0xed, 0x79, 0xed, 0xe3, 0xf6, 0xbc, 0xf6, 0x49, 0x7b, 0x5e,
1017 0xfb, 0x7b, 0x7b, 0x5e, 0xfb, 0xf1, 0x3f, 0xe6, 0x8f, 0x7d, 0xed, 0xf9, 0x23, 0xfd, 0x2b, 0xc1,
1018 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xdf, 0xe3, 0x03, 0xa1, 0x8a, 0x30, 0x00, 0x00,
1019 }
1020
1021 func (m *ConversionRequest) Marshal() (dAtA []byte, err error) {
1022 size := m.Size()
1023 dAtA = make([]byte, size)
1024 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1025 if err != nil {
1026 return nil, err
1027 }
1028 return dAtA[:n], nil
1029 }
1030
1031 func (m *ConversionRequest) MarshalTo(dAtA []byte) (int, error) {
1032 size := m.Size()
1033 return m.MarshalToSizedBuffer(dAtA[:size])
1034 }
1035
1036 func (m *ConversionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1037 i := len(dAtA)
1038 _ = i
1039 var l int
1040 _ = l
1041 if len(m.Objects) > 0 {
1042 for iNdEx := len(m.Objects) - 1; iNdEx >= 0; iNdEx-- {
1043 {
1044 size, err := m.Objects[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1045 if err != nil {
1046 return 0, err
1047 }
1048 i -= size
1049 i = encodeVarintGenerated(dAtA, i, uint64(size))
1050 }
1051 i--
1052 dAtA[i] = 0x1a
1053 }
1054 }
1055 i -= len(m.DesiredAPIVersion)
1056 copy(dAtA[i:], m.DesiredAPIVersion)
1057 i = encodeVarintGenerated(dAtA, i, uint64(len(m.DesiredAPIVersion)))
1058 i--
1059 dAtA[i] = 0x12
1060 i -= len(m.UID)
1061 copy(dAtA[i:], m.UID)
1062 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1063 i--
1064 dAtA[i] = 0xa
1065 return len(dAtA) - i, nil
1066 }
1067
1068 func (m *ConversionResponse) Marshal() (dAtA []byte, err error) {
1069 size := m.Size()
1070 dAtA = make([]byte, size)
1071 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1072 if err != nil {
1073 return nil, err
1074 }
1075 return dAtA[:n], nil
1076 }
1077
1078 func (m *ConversionResponse) MarshalTo(dAtA []byte) (int, error) {
1079 size := m.Size()
1080 return m.MarshalToSizedBuffer(dAtA[:size])
1081 }
1082
1083 func (m *ConversionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1084 i := len(dAtA)
1085 _ = i
1086 var l int
1087 _ = l
1088 {
1089 size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
1090 if err != nil {
1091 return 0, err
1092 }
1093 i -= size
1094 i = encodeVarintGenerated(dAtA, i, uint64(size))
1095 }
1096 i--
1097 dAtA[i] = 0x1a
1098 if len(m.ConvertedObjects) > 0 {
1099 for iNdEx := len(m.ConvertedObjects) - 1; iNdEx >= 0; iNdEx-- {
1100 {
1101 size, err := m.ConvertedObjects[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1102 if err != nil {
1103 return 0, err
1104 }
1105 i -= size
1106 i = encodeVarintGenerated(dAtA, i, uint64(size))
1107 }
1108 i--
1109 dAtA[i] = 0x12
1110 }
1111 }
1112 i -= len(m.UID)
1113 copy(dAtA[i:], m.UID)
1114 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1115 i--
1116 dAtA[i] = 0xa
1117 return len(dAtA) - i, nil
1118 }
1119
1120 func (m *ConversionReview) Marshal() (dAtA []byte, err error) {
1121 size := m.Size()
1122 dAtA = make([]byte, size)
1123 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1124 if err != nil {
1125 return nil, err
1126 }
1127 return dAtA[:n], nil
1128 }
1129
1130 func (m *ConversionReview) MarshalTo(dAtA []byte) (int, error) {
1131 size := m.Size()
1132 return m.MarshalToSizedBuffer(dAtA[:size])
1133 }
1134
1135 func (m *ConversionReview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1136 i := len(dAtA)
1137 _ = i
1138 var l int
1139 _ = l
1140 if m.Response != nil {
1141 {
1142 size, err := m.Response.MarshalToSizedBuffer(dAtA[:i])
1143 if err != nil {
1144 return 0, err
1145 }
1146 i -= size
1147 i = encodeVarintGenerated(dAtA, i, uint64(size))
1148 }
1149 i--
1150 dAtA[i] = 0x12
1151 }
1152 if m.Request != nil {
1153 {
1154 size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
1155 if err != nil {
1156 return 0, err
1157 }
1158 i -= size
1159 i = encodeVarintGenerated(dAtA, i, uint64(size))
1160 }
1161 i--
1162 dAtA[i] = 0xa
1163 }
1164 return len(dAtA) - i, nil
1165 }
1166
1167 func (m *CustomResourceColumnDefinition) Marshal() (dAtA []byte, err error) {
1168 size := m.Size()
1169 dAtA = make([]byte, size)
1170 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1171 if err != nil {
1172 return nil, err
1173 }
1174 return dAtA[:n], nil
1175 }
1176
1177 func (m *CustomResourceColumnDefinition) MarshalTo(dAtA []byte) (int, error) {
1178 size := m.Size()
1179 return m.MarshalToSizedBuffer(dAtA[:size])
1180 }
1181
1182 func (m *CustomResourceColumnDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1183 i := len(dAtA)
1184 _ = i
1185 var l int
1186 _ = l
1187 i -= len(m.JSONPath)
1188 copy(dAtA[i:], m.JSONPath)
1189 i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONPath)))
1190 i--
1191 dAtA[i] = 0x32
1192 i = encodeVarintGenerated(dAtA, i, uint64(m.Priority))
1193 i--
1194 dAtA[i] = 0x28
1195 i -= len(m.Description)
1196 copy(dAtA[i:], m.Description)
1197 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
1198 i--
1199 dAtA[i] = 0x22
1200 i -= len(m.Format)
1201 copy(dAtA[i:], m.Format)
1202 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format)))
1203 i--
1204 dAtA[i] = 0x1a
1205 i -= len(m.Type)
1206 copy(dAtA[i:], m.Type)
1207 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1208 i--
1209 dAtA[i] = 0x12
1210 i -= len(m.Name)
1211 copy(dAtA[i:], m.Name)
1212 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1213 i--
1214 dAtA[i] = 0xa
1215 return len(dAtA) - i, nil
1216 }
1217
1218 func (m *CustomResourceConversion) Marshal() (dAtA []byte, err error) {
1219 size := m.Size()
1220 dAtA = make([]byte, size)
1221 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1222 if err != nil {
1223 return nil, err
1224 }
1225 return dAtA[:n], nil
1226 }
1227
1228 func (m *CustomResourceConversion) MarshalTo(dAtA []byte) (int, error) {
1229 size := m.Size()
1230 return m.MarshalToSizedBuffer(dAtA[:size])
1231 }
1232
1233 func (m *CustomResourceConversion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1234 i := len(dAtA)
1235 _ = i
1236 var l int
1237 _ = l
1238 if len(m.ConversionReviewVersions) > 0 {
1239 for iNdEx := len(m.ConversionReviewVersions) - 1; iNdEx >= 0; iNdEx-- {
1240 i -= len(m.ConversionReviewVersions[iNdEx])
1241 copy(dAtA[i:], m.ConversionReviewVersions[iNdEx])
1242 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ConversionReviewVersions[iNdEx])))
1243 i--
1244 dAtA[i] = 0x1a
1245 }
1246 }
1247 if m.WebhookClientConfig != nil {
1248 {
1249 size, err := m.WebhookClientConfig.MarshalToSizedBuffer(dAtA[:i])
1250 if err != nil {
1251 return 0, err
1252 }
1253 i -= size
1254 i = encodeVarintGenerated(dAtA, i, uint64(size))
1255 }
1256 i--
1257 dAtA[i] = 0x12
1258 }
1259 i -= len(m.Strategy)
1260 copy(dAtA[i:], m.Strategy)
1261 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Strategy)))
1262 i--
1263 dAtA[i] = 0xa
1264 return len(dAtA) - i, nil
1265 }
1266
1267 func (m *CustomResourceDefinition) Marshal() (dAtA []byte, err error) {
1268 size := m.Size()
1269 dAtA = make([]byte, size)
1270 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1271 if err != nil {
1272 return nil, err
1273 }
1274 return dAtA[:n], nil
1275 }
1276
1277 func (m *CustomResourceDefinition) MarshalTo(dAtA []byte) (int, error) {
1278 size := m.Size()
1279 return m.MarshalToSizedBuffer(dAtA[:size])
1280 }
1281
1282 func (m *CustomResourceDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1283 i := len(dAtA)
1284 _ = i
1285 var l int
1286 _ = l
1287 {
1288 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1289 if err != nil {
1290 return 0, err
1291 }
1292 i -= size
1293 i = encodeVarintGenerated(dAtA, i, uint64(size))
1294 }
1295 i--
1296 dAtA[i] = 0x1a
1297 {
1298 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1299 if err != nil {
1300 return 0, err
1301 }
1302 i -= size
1303 i = encodeVarintGenerated(dAtA, i, uint64(size))
1304 }
1305 i--
1306 dAtA[i] = 0x12
1307 {
1308 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1309 if err != nil {
1310 return 0, err
1311 }
1312 i -= size
1313 i = encodeVarintGenerated(dAtA, i, uint64(size))
1314 }
1315 i--
1316 dAtA[i] = 0xa
1317 return len(dAtA) - i, nil
1318 }
1319
1320 func (m *CustomResourceDefinitionCondition) Marshal() (dAtA []byte, err error) {
1321 size := m.Size()
1322 dAtA = make([]byte, size)
1323 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1324 if err != nil {
1325 return nil, err
1326 }
1327 return dAtA[:n], nil
1328 }
1329
1330 func (m *CustomResourceDefinitionCondition) MarshalTo(dAtA []byte) (int, error) {
1331 size := m.Size()
1332 return m.MarshalToSizedBuffer(dAtA[:size])
1333 }
1334
1335 func (m *CustomResourceDefinitionCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1336 i := len(dAtA)
1337 _ = i
1338 var l int
1339 _ = l
1340 i -= len(m.Message)
1341 copy(dAtA[i:], m.Message)
1342 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1343 i--
1344 dAtA[i] = 0x2a
1345 i -= len(m.Reason)
1346 copy(dAtA[i:], m.Reason)
1347 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1348 i--
1349 dAtA[i] = 0x22
1350 {
1351 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1352 if err != nil {
1353 return 0, err
1354 }
1355 i -= size
1356 i = encodeVarintGenerated(dAtA, i, uint64(size))
1357 }
1358 i--
1359 dAtA[i] = 0x1a
1360 i -= len(m.Status)
1361 copy(dAtA[i:], m.Status)
1362 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1363 i--
1364 dAtA[i] = 0x12
1365 i -= len(m.Type)
1366 copy(dAtA[i:], m.Type)
1367 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1368 i--
1369 dAtA[i] = 0xa
1370 return len(dAtA) - i, nil
1371 }
1372
1373 func (m *CustomResourceDefinitionList) Marshal() (dAtA []byte, err error) {
1374 size := m.Size()
1375 dAtA = make([]byte, size)
1376 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1377 if err != nil {
1378 return nil, err
1379 }
1380 return dAtA[:n], nil
1381 }
1382
1383 func (m *CustomResourceDefinitionList) MarshalTo(dAtA []byte) (int, error) {
1384 size := m.Size()
1385 return m.MarshalToSizedBuffer(dAtA[:size])
1386 }
1387
1388 func (m *CustomResourceDefinitionList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1389 i := len(dAtA)
1390 _ = i
1391 var l int
1392 _ = l
1393 if len(m.Items) > 0 {
1394 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1395 {
1396 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1397 if err != nil {
1398 return 0, err
1399 }
1400 i -= size
1401 i = encodeVarintGenerated(dAtA, i, uint64(size))
1402 }
1403 i--
1404 dAtA[i] = 0x12
1405 }
1406 }
1407 {
1408 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1409 if err != nil {
1410 return 0, err
1411 }
1412 i -= size
1413 i = encodeVarintGenerated(dAtA, i, uint64(size))
1414 }
1415 i--
1416 dAtA[i] = 0xa
1417 return len(dAtA) - i, nil
1418 }
1419
1420 func (m *CustomResourceDefinitionNames) Marshal() (dAtA []byte, err error) {
1421 size := m.Size()
1422 dAtA = make([]byte, size)
1423 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1424 if err != nil {
1425 return nil, err
1426 }
1427 return dAtA[:n], nil
1428 }
1429
1430 func (m *CustomResourceDefinitionNames) MarshalTo(dAtA []byte) (int, error) {
1431 size := m.Size()
1432 return m.MarshalToSizedBuffer(dAtA[:size])
1433 }
1434
1435 func (m *CustomResourceDefinitionNames) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1436 i := len(dAtA)
1437 _ = i
1438 var l int
1439 _ = l
1440 if len(m.Categories) > 0 {
1441 for iNdEx := len(m.Categories) - 1; iNdEx >= 0; iNdEx-- {
1442 i -= len(m.Categories[iNdEx])
1443 copy(dAtA[i:], m.Categories[iNdEx])
1444 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Categories[iNdEx])))
1445 i--
1446 dAtA[i] = 0x32
1447 }
1448 }
1449 i -= len(m.ListKind)
1450 copy(dAtA[i:], m.ListKind)
1451 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ListKind)))
1452 i--
1453 dAtA[i] = 0x2a
1454 i -= len(m.Kind)
1455 copy(dAtA[i:], m.Kind)
1456 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1457 i--
1458 dAtA[i] = 0x22
1459 if len(m.ShortNames) > 0 {
1460 for iNdEx := len(m.ShortNames) - 1; iNdEx >= 0; iNdEx-- {
1461 i -= len(m.ShortNames[iNdEx])
1462 copy(dAtA[i:], m.ShortNames[iNdEx])
1463 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ShortNames[iNdEx])))
1464 i--
1465 dAtA[i] = 0x1a
1466 }
1467 }
1468 i -= len(m.Singular)
1469 copy(dAtA[i:], m.Singular)
1470 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Singular)))
1471 i--
1472 dAtA[i] = 0x12
1473 i -= len(m.Plural)
1474 copy(dAtA[i:], m.Plural)
1475 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Plural)))
1476 i--
1477 dAtA[i] = 0xa
1478 return len(dAtA) - i, nil
1479 }
1480
1481 func (m *CustomResourceDefinitionSpec) Marshal() (dAtA []byte, err error) {
1482 size := m.Size()
1483 dAtA = make([]byte, size)
1484 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1485 if err != nil {
1486 return nil, err
1487 }
1488 return dAtA[:n], nil
1489 }
1490
1491 func (m *CustomResourceDefinitionSpec) MarshalTo(dAtA []byte) (int, error) {
1492 size := m.Size()
1493 return m.MarshalToSizedBuffer(dAtA[:size])
1494 }
1495
1496 func (m *CustomResourceDefinitionSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1497 i := len(dAtA)
1498 _ = i
1499 var l int
1500 _ = l
1501 if len(m.SelectableFields) > 0 {
1502 for iNdEx := len(m.SelectableFields) - 1; iNdEx >= 0; iNdEx-- {
1503 {
1504 size, err := m.SelectableFields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1505 if err != nil {
1506 return 0, err
1507 }
1508 i -= size
1509 i = encodeVarintGenerated(dAtA, i, uint64(size))
1510 }
1511 i--
1512 dAtA[i] = 0x5a
1513 }
1514 }
1515 if m.PreserveUnknownFields != nil {
1516 i--
1517 if *m.PreserveUnknownFields {
1518 dAtA[i] = 1
1519 } else {
1520 dAtA[i] = 0
1521 }
1522 i--
1523 dAtA[i] = 0x50
1524 }
1525 if m.Conversion != nil {
1526 {
1527 size, err := m.Conversion.MarshalToSizedBuffer(dAtA[:i])
1528 if err != nil {
1529 return 0, err
1530 }
1531 i -= size
1532 i = encodeVarintGenerated(dAtA, i, uint64(size))
1533 }
1534 i--
1535 dAtA[i] = 0x4a
1536 }
1537 if len(m.AdditionalPrinterColumns) > 0 {
1538 for iNdEx := len(m.AdditionalPrinterColumns) - 1; iNdEx >= 0; iNdEx-- {
1539 {
1540 size, err := m.AdditionalPrinterColumns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1541 if err != nil {
1542 return 0, err
1543 }
1544 i -= size
1545 i = encodeVarintGenerated(dAtA, i, uint64(size))
1546 }
1547 i--
1548 dAtA[i] = 0x42
1549 }
1550 }
1551 if len(m.Versions) > 0 {
1552 for iNdEx := len(m.Versions) - 1; iNdEx >= 0; iNdEx-- {
1553 {
1554 size, err := m.Versions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1555 if err != nil {
1556 return 0, err
1557 }
1558 i -= size
1559 i = encodeVarintGenerated(dAtA, i, uint64(size))
1560 }
1561 i--
1562 dAtA[i] = 0x3a
1563 }
1564 }
1565 if m.Subresources != nil {
1566 {
1567 size, err := m.Subresources.MarshalToSizedBuffer(dAtA[:i])
1568 if err != nil {
1569 return 0, err
1570 }
1571 i -= size
1572 i = encodeVarintGenerated(dAtA, i, uint64(size))
1573 }
1574 i--
1575 dAtA[i] = 0x32
1576 }
1577 if m.Validation != nil {
1578 {
1579 size, err := m.Validation.MarshalToSizedBuffer(dAtA[:i])
1580 if err != nil {
1581 return 0, err
1582 }
1583 i -= size
1584 i = encodeVarintGenerated(dAtA, i, uint64(size))
1585 }
1586 i--
1587 dAtA[i] = 0x2a
1588 }
1589 i -= len(m.Scope)
1590 copy(dAtA[i:], m.Scope)
1591 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scope)))
1592 i--
1593 dAtA[i] = 0x22
1594 {
1595 size, err := m.Names.MarshalToSizedBuffer(dAtA[:i])
1596 if err != nil {
1597 return 0, err
1598 }
1599 i -= size
1600 i = encodeVarintGenerated(dAtA, i, uint64(size))
1601 }
1602 i--
1603 dAtA[i] = 0x1a
1604 i -= len(m.Version)
1605 copy(dAtA[i:], m.Version)
1606 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
1607 i--
1608 dAtA[i] = 0x12
1609 i -= len(m.Group)
1610 copy(dAtA[i:], m.Group)
1611 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
1612 i--
1613 dAtA[i] = 0xa
1614 return len(dAtA) - i, nil
1615 }
1616
1617 func (m *CustomResourceDefinitionStatus) Marshal() (dAtA []byte, err error) {
1618 size := m.Size()
1619 dAtA = make([]byte, size)
1620 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1621 if err != nil {
1622 return nil, err
1623 }
1624 return dAtA[:n], nil
1625 }
1626
1627 func (m *CustomResourceDefinitionStatus) MarshalTo(dAtA []byte) (int, error) {
1628 size := m.Size()
1629 return m.MarshalToSizedBuffer(dAtA[:size])
1630 }
1631
1632 func (m *CustomResourceDefinitionStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1633 i := len(dAtA)
1634 _ = i
1635 var l int
1636 _ = l
1637 if len(m.StoredVersions) > 0 {
1638 for iNdEx := len(m.StoredVersions) - 1; iNdEx >= 0; iNdEx-- {
1639 i -= len(m.StoredVersions[iNdEx])
1640 copy(dAtA[i:], m.StoredVersions[iNdEx])
1641 i = encodeVarintGenerated(dAtA, i, uint64(len(m.StoredVersions[iNdEx])))
1642 i--
1643 dAtA[i] = 0x1a
1644 }
1645 }
1646 {
1647 size, err := m.AcceptedNames.MarshalToSizedBuffer(dAtA[:i])
1648 if err != nil {
1649 return 0, err
1650 }
1651 i -= size
1652 i = encodeVarintGenerated(dAtA, i, uint64(size))
1653 }
1654 i--
1655 dAtA[i] = 0x12
1656 if len(m.Conditions) > 0 {
1657 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1658 {
1659 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1660 if err != nil {
1661 return 0, err
1662 }
1663 i -= size
1664 i = encodeVarintGenerated(dAtA, i, uint64(size))
1665 }
1666 i--
1667 dAtA[i] = 0xa
1668 }
1669 }
1670 return len(dAtA) - i, nil
1671 }
1672
1673 func (m *CustomResourceDefinitionVersion) Marshal() (dAtA []byte, err error) {
1674 size := m.Size()
1675 dAtA = make([]byte, size)
1676 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1677 if err != nil {
1678 return nil, err
1679 }
1680 return dAtA[:n], nil
1681 }
1682
1683 func (m *CustomResourceDefinitionVersion) MarshalTo(dAtA []byte) (int, error) {
1684 size := m.Size()
1685 return m.MarshalToSizedBuffer(dAtA[:size])
1686 }
1687
1688 func (m *CustomResourceDefinitionVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1689 i := len(dAtA)
1690 _ = i
1691 var l int
1692 _ = l
1693 if len(m.SelectableFields) > 0 {
1694 for iNdEx := len(m.SelectableFields) - 1; iNdEx >= 0; iNdEx-- {
1695 {
1696 size, err := m.SelectableFields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1697 if err != nil {
1698 return 0, err
1699 }
1700 i -= size
1701 i = encodeVarintGenerated(dAtA, i, uint64(size))
1702 }
1703 i--
1704 dAtA[i] = 0x4a
1705 }
1706 }
1707 if m.DeprecationWarning != nil {
1708 i -= len(*m.DeprecationWarning)
1709 copy(dAtA[i:], *m.DeprecationWarning)
1710 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.DeprecationWarning)))
1711 i--
1712 dAtA[i] = 0x42
1713 }
1714 i--
1715 if m.Deprecated {
1716 dAtA[i] = 1
1717 } else {
1718 dAtA[i] = 0
1719 }
1720 i--
1721 dAtA[i] = 0x38
1722 if len(m.AdditionalPrinterColumns) > 0 {
1723 for iNdEx := len(m.AdditionalPrinterColumns) - 1; iNdEx >= 0; iNdEx-- {
1724 {
1725 size, err := m.AdditionalPrinterColumns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1726 if err != nil {
1727 return 0, err
1728 }
1729 i -= size
1730 i = encodeVarintGenerated(dAtA, i, uint64(size))
1731 }
1732 i--
1733 dAtA[i] = 0x32
1734 }
1735 }
1736 if m.Subresources != nil {
1737 {
1738 size, err := m.Subresources.MarshalToSizedBuffer(dAtA[:i])
1739 if err != nil {
1740 return 0, err
1741 }
1742 i -= size
1743 i = encodeVarintGenerated(dAtA, i, uint64(size))
1744 }
1745 i--
1746 dAtA[i] = 0x2a
1747 }
1748 if m.Schema != nil {
1749 {
1750 size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
1751 if err != nil {
1752 return 0, err
1753 }
1754 i -= size
1755 i = encodeVarintGenerated(dAtA, i, uint64(size))
1756 }
1757 i--
1758 dAtA[i] = 0x22
1759 }
1760 i--
1761 if m.Storage {
1762 dAtA[i] = 1
1763 } else {
1764 dAtA[i] = 0
1765 }
1766 i--
1767 dAtA[i] = 0x18
1768 i--
1769 if m.Served {
1770 dAtA[i] = 1
1771 } else {
1772 dAtA[i] = 0
1773 }
1774 i--
1775 dAtA[i] = 0x10
1776 i -= len(m.Name)
1777 copy(dAtA[i:], m.Name)
1778 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1779 i--
1780 dAtA[i] = 0xa
1781 return len(dAtA) - i, nil
1782 }
1783
1784 func (m *CustomResourceSubresourceScale) Marshal() (dAtA []byte, err error) {
1785 size := m.Size()
1786 dAtA = make([]byte, size)
1787 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1788 if err != nil {
1789 return nil, err
1790 }
1791 return dAtA[:n], nil
1792 }
1793
1794 func (m *CustomResourceSubresourceScale) MarshalTo(dAtA []byte) (int, error) {
1795 size := m.Size()
1796 return m.MarshalToSizedBuffer(dAtA[:size])
1797 }
1798
1799 func (m *CustomResourceSubresourceScale) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1800 i := len(dAtA)
1801 _ = i
1802 var l int
1803 _ = l
1804 if m.LabelSelectorPath != nil {
1805 i -= len(*m.LabelSelectorPath)
1806 copy(dAtA[i:], *m.LabelSelectorPath)
1807 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.LabelSelectorPath)))
1808 i--
1809 dAtA[i] = 0x1a
1810 }
1811 i -= len(m.StatusReplicasPath)
1812 copy(dAtA[i:], m.StatusReplicasPath)
1813 i = encodeVarintGenerated(dAtA, i, uint64(len(m.StatusReplicasPath)))
1814 i--
1815 dAtA[i] = 0x12
1816 i -= len(m.SpecReplicasPath)
1817 copy(dAtA[i:], m.SpecReplicasPath)
1818 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SpecReplicasPath)))
1819 i--
1820 dAtA[i] = 0xa
1821 return len(dAtA) - i, nil
1822 }
1823
1824 func (m *CustomResourceSubresourceStatus) Marshal() (dAtA []byte, err error) {
1825 size := m.Size()
1826 dAtA = make([]byte, size)
1827 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1828 if err != nil {
1829 return nil, err
1830 }
1831 return dAtA[:n], nil
1832 }
1833
1834 func (m *CustomResourceSubresourceStatus) MarshalTo(dAtA []byte) (int, error) {
1835 size := m.Size()
1836 return m.MarshalToSizedBuffer(dAtA[:size])
1837 }
1838
1839 func (m *CustomResourceSubresourceStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1840 i := len(dAtA)
1841 _ = i
1842 var l int
1843 _ = l
1844 return len(dAtA) - i, nil
1845 }
1846
1847 func (m *CustomResourceSubresources) Marshal() (dAtA []byte, err error) {
1848 size := m.Size()
1849 dAtA = make([]byte, size)
1850 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1851 if err != nil {
1852 return nil, err
1853 }
1854 return dAtA[:n], nil
1855 }
1856
1857 func (m *CustomResourceSubresources) MarshalTo(dAtA []byte) (int, error) {
1858 size := m.Size()
1859 return m.MarshalToSizedBuffer(dAtA[:size])
1860 }
1861
1862 func (m *CustomResourceSubresources) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1863 i := len(dAtA)
1864 _ = i
1865 var l int
1866 _ = l
1867 if m.Scale != nil {
1868 {
1869 size, err := m.Scale.MarshalToSizedBuffer(dAtA[:i])
1870 if err != nil {
1871 return 0, err
1872 }
1873 i -= size
1874 i = encodeVarintGenerated(dAtA, i, uint64(size))
1875 }
1876 i--
1877 dAtA[i] = 0x12
1878 }
1879 if m.Status != nil {
1880 {
1881 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1882 if err != nil {
1883 return 0, err
1884 }
1885 i -= size
1886 i = encodeVarintGenerated(dAtA, i, uint64(size))
1887 }
1888 i--
1889 dAtA[i] = 0xa
1890 }
1891 return len(dAtA) - i, nil
1892 }
1893
1894 func (m *CustomResourceValidation) Marshal() (dAtA []byte, err error) {
1895 size := m.Size()
1896 dAtA = make([]byte, size)
1897 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1898 if err != nil {
1899 return nil, err
1900 }
1901 return dAtA[:n], nil
1902 }
1903
1904 func (m *CustomResourceValidation) MarshalTo(dAtA []byte) (int, error) {
1905 size := m.Size()
1906 return m.MarshalToSizedBuffer(dAtA[:size])
1907 }
1908
1909 func (m *CustomResourceValidation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1910 i := len(dAtA)
1911 _ = i
1912 var l int
1913 _ = l
1914 if m.OpenAPIV3Schema != nil {
1915 {
1916 size, err := m.OpenAPIV3Schema.MarshalToSizedBuffer(dAtA[:i])
1917 if err != nil {
1918 return 0, err
1919 }
1920 i -= size
1921 i = encodeVarintGenerated(dAtA, i, uint64(size))
1922 }
1923 i--
1924 dAtA[i] = 0xa
1925 }
1926 return len(dAtA) - i, nil
1927 }
1928
1929 func (m *ExternalDocumentation) Marshal() (dAtA []byte, err error) {
1930 size := m.Size()
1931 dAtA = make([]byte, size)
1932 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1933 if err != nil {
1934 return nil, err
1935 }
1936 return dAtA[:n], nil
1937 }
1938
1939 func (m *ExternalDocumentation) MarshalTo(dAtA []byte) (int, error) {
1940 size := m.Size()
1941 return m.MarshalToSizedBuffer(dAtA[:size])
1942 }
1943
1944 func (m *ExternalDocumentation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1945 i := len(dAtA)
1946 _ = i
1947 var l int
1948 _ = l
1949 i -= len(m.URL)
1950 copy(dAtA[i:], m.URL)
1951 i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
1952 i--
1953 dAtA[i] = 0x12
1954 i -= len(m.Description)
1955 copy(dAtA[i:], m.Description)
1956 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
1957 i--
1958 dAtA[i] = 0xa
1959 return len(dAtA) - i, nil
1960 }
1961
1962 func (m *JSON) Marshal() (dAtA []byte, err error) {
1963 size := m.Size()
1964 dAtA = make([]byte, size)
1965 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1966 if err != nil {
1967 return nil, err
1968 }
1969 return dAtA[:n], nil
1970 }
1971
1972 func (m *JSON) MarshalTo(dAtA []byte) (int, error) {
1973 size := m.Size()
1974 return m.MarshalToSizedBuffer(dAtA[:size])
1975 }
1976
1977 func (m *JSON) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1978 i := len(dAtA)
1979 _ = i
1980 var l int
1981 _ = l
1982 if m.Raw != nil {
1983 i -= len(m.Raw)
1984 copy(dAtA[i:], m.Raw)
1985 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw)))
1986 i--
1987 dAtA[i] = 0xa
1988 }
1989 return len(dAtA) - i, nil
1990 }
1991
1992 func (m *JSONSchemaProps) Marshal() (dAtA []byte, err error) {
1993 size := m.Size()
1994 dAtA = make([]byte, size)
1995 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1996 if err != nil {
1997 return nil, err
1998 }
1999 return dAtA[:n], nil
2000 }
2001
2002 func (m *JSONSchemaProps) MarshalTo(dAtA []byte) (int, error) {
2003 size := m.Size()
2004 return m.MarshalToSizedBuffer(dAtA[:size])
2005 }
2006
2007 func (m *JSONSchemaProps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2008 i := len(dAtA)
2009 _ = i
2010 var l int
2011 _ = l
2012 if len(m.XValidations) > 0 {
2013 for iNdEx := len(m.XValidations) - 1; iNdEx >= 0; iNdEx-- {
2014 {
2015 size, err := m.XValidations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2016 if err != nil {
2017 return 0, err
2018 }
2019 i -= size
2020 i = encodeVarintGenerated(dAtA, i, uint64(size))
2021 }
2022 i--
2023 dAtA[i] = 0x2
2024 i--
2025 dAtA[i] = 0xe2
2026 }
2027 }
2028 if m.XMapType != nil {
2029 i -= len(*m.XMapType)
2030 copy(dAtA[i:], *m.XMapType)
2031 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.XMapType)))
2032 i--
2033 dAtA[i] = 0x2
2034 i--
2035 dAtA[i] = 0xda
2036 }
2037 if m.XListType != nil {
2038 i -= len(*m.XListType)
2039 copy(dAtA[i:], *m.XListType)
2040 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.XListType)))
2041 i--
2042 dAtA[i] = 0x2
2043 i--
2044 dAtA[i] = 0xd2
2045 }
2046 if len(m.XListMapKeys) > 0 {
2047 for iNdEx := len(m.XListMapKeys) - 1; iNdEx >= 0; iNdEx-- {
2048 i -= len(m.XListMapKeys[iNdEx])
2049 copy(dAtA[i:], m.XListMapKeys[iNdEx])
2050 i = encodeVarintGenerated(dAtA, i, uint64(len(m.XListMapKeys[iNdEx])))
2051 i--
2052 dAtA[i] = 0x2
2053 i--
2054 dAtA[i] = 0xca
2055 }
2056 }
2057 i--
2058 if m.XIntOrString {
2059 dAtA[i] = 1
2060 } else {
2061 dAtA[i] = 0
2062 }
2063 i--
2064 dAtA[i] = 0x2
2065 i--
2066 dAtA[i] = 0xc0
2067 i--
2068 if m.XEmbeddedResource {
2069 dAtA[i] = 1
2070 } else {
2071 dAtA[i] = 0
2072 }
2073 i--
2074 dAtA[i] = 0x2
2075 i--
2076 dAtA[i] = 0xb8
2077 if m.XPreserveUnknownFields != nil {
2078 i--
2079 if *m.XPreserveUnknownFields {
2080 dAtA[i] = 1
2081 } else {
2082 dAtA[i] = 0
2083 }
2084 i--
2085 dAtA[i] = 0x2
2086 i--
2087 dAtA[i] = 0xb0
2088 }
2089 i--
2090 if m.Nullable {
2091 dAtA[i] = 1
2092 } else {
2093 dAtA[i] = 0
2094 }
2095 i--
2096 dAtA[i] = 0x2
2097 i--
2098 dAtA[i] = 0xa8
2099 if m.Example != nil {
2100 {
2101 size, err := m.Example.MarshalToSizedBuffer(dAtA[:i])
2102 if err != nil {
2103 return 0, err
2104 }
2105 i -= size
2106 i = encodeVarintGenerated(dAtA, i, uint64(size))
2107 }
2108 i--
2109 dAtA[i] = 0x2
2110 i--
2111 dAtA[i] = 0xa2
2112 }
2113 if m.ExternalDocs != nil {
2114 {
2115 size, err := m.ExternalDocs.MarshalToSizedBuffer(dAtA[:i])
2116 if err != nil {
2117 return 0, err
2118 }
2119 i -= size
2120 i = encodeVarintGenerated(dAtA, i, uint64(size))
2121 }
2122 i--
2123 dAtA[i] = 0x2
2124 i--
2125 dAtA[i] = 0x9a
2126 }
2127 if len(m.Definitions) > 0 {
2128 keysForDefinitions := make([]string, 0, len(m.Definitions))
2129 for k := range m.Definitions {
2130 keysForDefinitions = append(keysForDefinitions, string(k))
2131 }
2132 github_com_gogo_protobuf_sortkeys.Strings(keysForDefinitions)
2133 for iNdEx := len(keysForDefinitions) - 1; iNdEx >= 0; iNdEx-- {
2134 v := m.Definitions[string(keysForDefinitions[iNdEx])]
2135 baseI := i
2136 {
2137 size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
2138 if err != nil {
2139 return 0, err
2140 }
2141 i -= size
2142 i = encodeVarintGenerated(dAtA, i, uint64(size))
2143 }
2144 i--
2145 dAtA[i] = 0x12
2146 i -= len(keysForDefinitions[iNdEx])
2147 copy(dAtA[i:], keysForDefinitions[iNdEx])
2148 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForDefinitions[iNdEx])))
2149 i--
2150 dAtA[i] = 0xa
2151 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
2152 i--
2153 dAtA[i] = 0x2
2154 i--
2155 dAtA[i] = 0x92
2156 }
2157 }
2158 if m.AdditionalItems != nil {
2159 {
2160 size, err := m.AdditionalItems.MarshalToSizedBuffer(dAtA[:i])
2161 if err != nil {
2162 return 0, err
2163 }
2164 i -= size
2165 i = encodeVarintGenerated(dAtA, i, uint64(size))
2166 }
2167 i--
2168 dAtA[i] = 0x2
2169 i--
2170 dAtA[i] = 0x8a
2171 }
2172 if len(m.Dependencies) > 0 {
2173 keysForDependencies := make([]string, 0, len(m.Dependencies))
2174 for k := range m.Dependencies {
2175 keysForDependencies = append(keysForDependencies, string(k))
2176 }
2177 github_com_gogo_protobuf_sortkeys.Strings(keysForDependencies)
2178 for iNdEx := len(keysForDependencies) - 1; iNdEx >= 0; iNdEx-- {
2179 v := m.Dependencies[string(keysForDependencies[iNdEx])]
2180 baseI := i
2181 {
2182 size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
2183 if err != nil {
2184 return 0, err
2185 }
2186 i -= size
2187 i = encodeVarintGenerated(dAtA, i, uint64(size))
2188 }
2189 i--
2190 dAtA[i] = 0x12
2191 i -= len(keysForDependencies[iNdEx])
2192 copy(dAtA[i:], keysForDependencies[iNdEx])
2193 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForDependencies[iNdEx])))
2194 i--
2195 dAtA[i] = 0xa
2196 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
2197 i--
2198 dAtA[i] = 0x2
2199 i--
2200 dAtA[i] = 0x82
2201 }
2202 }
2203 if len(m.PatternProperties) > 0 {
2204 keysForPatternProperties := make([]string, 0, len(m.PatternProperties))
2205 for k := range m.PatternProperties {
2206 keysForPatternProperties = append(keysForPatternProperties, string(k))
2207 }
2208 github_com_gogo_protobuf_sortkeys.Strings(keysForPatternProperties)
2209 for iNdEx := len(keysForPatternProperties) - 1; iNdEx >= 0; iNdEx-- {
2210 v := m.PatternProperties[string(keysForPatternProperties[iNdEx])]
2211 baseI := i
2212 {
2213 size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
2214 if err != nil {
2215 return 0, err
2216 }
2217 i -= size
2218 i = encodeVarintGenerated(dAtA, i, uint64(size))
2219 }
2220 i--
2221 dAtA[i] = 0x12
2222 i -= len(keysForPatternProperties[iNdEx])
2223 copy(dAtA[i:], keysForPatternProperties[iNdEx])
2224 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPatternProperties[iNdEx])))
2225 i--
2226 dAtA[i] = 0xa
2227 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
2228 i--
2229 dAtA[i] = 0x1
2230 i--
2231 dAtA[i] = 0xfa
2232 }
2233 }
2234 if m.AdditionalProperties != nil {
2235 {
2236 size, err := m.AdditionalProperties.MarshalToSizedBuffer(dAtA[:i])
2237 if err != nil {
2238 return 0, err
2239 }
2240 i -= size
2241 i = encodeVarintGenerated(dAtA, i, uint64(size))
2242 }
2243 i--
2244 dAtA[i] = 0x1
2245 i--
2246 dAtA[i] = 0xf2
2247 }
2248 if len(m.Properties) > 0 {
2249 keysForProperties := make([]string, 0, len(m.Properties))
2250 for k := range m.Properties {
2251 keysForProperties = append(keysForProperties, string(k))
2252 }
2253 github_com_gogo_protobuf_sortkeys.Strings(keysForProperties)
2254 for iNdEx := len(keysForProperties) - 1; iNdEx >= 0; iNdEx-- {
2255 v := m.Properties[string(keysForProperties[iNdEx])]
2256 baseI := i
2257 {
2258 size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
2259 if err != nil {
2260 return 0, err
2261 }
2262 i -= size
2263 i = encodeVarintGenerated(dAtA, i, uint64(size))
2264 }
2265 i--
2266 dAtA[i] = 0x12
2267 i -= len(keysForProperties[iNdEx])
2268 copy(dAtA[i:], keysForProperties[iNdEx])
2269 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForProperties[iNdEx])))
2270 i--
2271 dAtA[i] = 0xa
2272 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
2273 i--
2274 dAtA[i] = 0x1
2275 i--
2276 dAtA[i] = 0xea
2277 }
2278 }
2279 if m.Not != nil {
2280 {
2281 size, err := m.Not.MarshalToSizedBuffer(dAtA[:i])
2282 if err != nil {
2283 return 0, err
2284 }
2285 i -= size
2286 i = encodeVarintGenerated(dAtA, i, uint64(size))
2287 }
2288 i--
2289 dAtA[i] = 0x1
2290 i--
2291 dAtA[i] = 0xe2
2292 }
2293 if len(m.AnyOf) > 0 {
2294 for iNdEx := len(m.AnyOf) - 1; iNdEx >= 0; iNdEx-- {
2295 {
2296 size, err := m.AnyOf[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2297 if err != nil {
2298 return 0, err
2299 }
2300 i -= size
2301 i = encodeVarintGenerated(dAtA, i, uint64(size))
2302 }
2303 i--
2304 dAtA[i] = 0x1
2305 i--
2306 dAtA[i] = 0xda
2307 }
2308 }
2309 if len(m.OneOf) > 0 {
2310 for iNdEx := len(m.OneOf) - 1; iNdEx >= 0; iNdEx-- {
2311 {
2312 size, err := m.OneOf[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2313 if err != nil {
2314 return 0, err
2315 }
2316 i -= size
2317 i = encodeVarintGenerated(dAtA, i, uint64(size))
2318 }
2319 i--
2320 dAtA[i] = 0x1
2321 i--
2322 dAtA[i] = 0xd2
2323 }
2324 }
2325 if len(m.AllOf) > 0 {
2326 for iNdEx := len(m.AllOf) - 1; iNdEx >= 0; iNdEx-- {
2327 {
2328 size, err := m.AllOf[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2329 if err != nil {
2330 return 0, err
2331 }
2332 i -= size
2333 i = encodeVarintGenerated(dAtA, i, uint64(size))
2334 }
2335 i--
2336 dAtA[i] = 0x1
2337 i--
2338 dAtA[i] = 0xca
2339 }
2340 }
2341 if m.Items != nil {
2342 {
2343 size, err := m.Items.MarshalToSizedBuffer(dAtA[:i])
2344 if err != nil {
2345 return 0, err
2346 }
2347 i -= size
2348 i = encodeVarintGenerated(dAtA, i, uint64(size))
2349 }
2350 i--
2351 dAtA[i] = 0x1
2352 i--
2353 dAtA[i] = 0xc2
2354 }
2355 if len(m.Required) > 0 {
2356 for iNdEx := len(m.Required) - 1; iNdEx >= 0; iNdEx-- {
2357 i -= len(m.Required[iNdEx])
2358 copy(dAtA[i:], m.Required[iNdEx])
2359 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Required[iNdEx])))
2360 i--
2361 dAtA[i] = 0x1
2362 i--
2363 dAtA[i] = 0xba
2364 }
2365 }
2366 if m.MinProperties != nil {
2367 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinProperties))
2368 i--
2369 dAtA[i] = 0x1
2370 i--
2371 dAtA[i] = 0xb0
2372 }
2373 if m.MaxProperties != nil {
2374 i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxProperties))
2375 i--
2376 dAtA[i] = 0x1
2377 i--
2378 dAtA[i] = 0xa8
2379 }
2380 if len(m.Enum) > 0 {
2381 for iNdEx := len(m.Enum) - 1; iNdEx >= 0; iNdEx-- {
2382 {
2383 size, err := m.Enum[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2384 if err != nil {
2385 return 0, err
2386 }
2387 i -= size
2388 i = encodeVarintGenerated(dAtA, i, uint64(size))
2389 }
2390 i--
2391 dAtA[i] = 0x1
2392 i--
2393 dAtA[i] = 0xa2
2394 }
2395 }
2396 if m.MultipleOf != nil {
2397 i -= 8
2398 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.MultipleOf))))
2399 i--
2400 dAtA[i] = 0x1
2401 i--
2402 dAtA[i] = 0x99
2403 }
2404 i--
2405 if m.UniqueItems {
2406 dAtA[i] = 1
2407 } else {
2408 dAtA[i] = 0
2409 }
2410 i--
2411 dAtA[i] = 0x1
2412 i--
2413 dAtA[i] = 0x90
2414 if m.MinItems != nil {
2415 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinItems))
2416 i--
2417 dAtA[i] = 0x1
2418 i--
2419 dAtA[i] = 0x88
2420 }
2421 if m.MaxItems != nil {
2422 i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxItems))
2423 i--
2424 dAtA[i] = 0x1
2425 i--
2426 dAtA[i] = 0x80
2427 }
2428 i -= len(m.Pattern)
2429 copy(dAtA[i:], m.Pattern)
2430 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Pattern)))
2431 i--
2432 dAtA[i] = 0x7a
2433 if m.MinLength != nil {
2434 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinLength))
2435 i--
2436 dAtA[i] = 0x70
2437 }
2438 if m.MaxLength != nil {
2439 i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxLength))
2440 i--
2441 dAtA[i] = 0x68
2442 }
2443 i--
2444 if m.ExclusiveMinimum {
2445 dAtA[i] = 1
2446 } else {
2447 dAtA[i] = 0
2448 }
2449 i--
2450 dAtA[i] = 0x60
2451 if m.Minimum != nil {
2452 i -= 8
2453 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Minimum))))
2454 i--
2455 dAtA[i] = 0x59
2456 }
2457 i--
2458 if m.ExclusiveMaximum {
2459 dAtA[i] = 1
2460 } else {
2461 dAtA[i] = 0
2462 }
2463 i--
2464 dAtA[i] = 0x50
2465 if m.Maximum != nil {
2466 i -= 8
2467 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Maximum))))
2468 i--
2469 dAtA[i] = 0x49
2470 }
2471 if m.Default != nil {
2472 {
2473 size, err := m.Default.MarshalToSizedBuffer(dAtA[:i])
2474 if err != nil {
2475 return 0, err
2476 }
2477 i -= size
2478 i = encodeVarintGenerated(dAtA, i, uint64(size))
2479 }
2480 i--
2481 dAtA[i] = 0x42
2482 }
2483 i -= len(m.Title)
2484 copy(dAtA[i:], m.Title)
2485 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Title)))
2486 i--
2487 dAtA[i] = 0x3a
2488 i -= len(m.Format)
2489 copy(dAtA[i:], m.Format)
2490 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format)))
2491 i--
2492 dAtA[i] = 0x32
2493 i -= len(m.Type)
2494 copy(dAtA[i:], m.Type)
2495 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2496 i--
2497 dAtA[i] = 0x2a
2498 i -= len(m.Description)
2499 copy(dAtA[i:], m.Description)
2500 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
2501 i--
2502 dAtA[i] = 0x22
2503 if m.Ref != nil {
2504 i -= len(*m.Ref)
2505 copy(dAtA[i:], *m.Ref)
2506 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Ref)))
2507 i--
2508 dAtA[i] = 0x1a
2509 }
2510 i -= len(m.Schema)
2511 copy(dAtA[i:], m.Schema)
2512 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Schema)))
2513 i--
2514 dAtA[i] = 0x12
2515 i -= len(m.ID)
2516 copy(dAtA[i:], m.ID)
2517 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ID)))
2518 i--
2519 dAtA[i] = 0xa
2520 return len(dAtA) - i, nil
2521 }
2522
2523 func (m *JSONSchemaPropsOrArray) Marshal() (dAtA []byte, err error) {
2524 size := m.Size()
2525 dAtA = make([]byte, size)
2526 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2527 if err != nil {
2528 return nil, err
2529 }
2530 return dAtA[:n], nil
2531 }
2532
2533 func (m *JSONSchemaPropsOrArray) MarshalTo(dAtA []byte) (int, error) {
2534 size := m.Size()
2535 return m.MarshalToSizedBuffer(dAtA[:size])
2536 }
2537
2538 func (m *JSONSchemaPropsOrArray) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2539 i := len(dAtA)
2540 _ = i
2541 var l int
2542 _ = l
2543 if len(m.JSONSchemas) > 0 {
2544 for iNdEx := len(m.JSONSchemas) - 1; iNdEx >= 0; iNdEx-- {
2545 {
2546 size, err := m.JSONSchemas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2547 if err != nil {
2548 return 0, err
2549 }
2550 i -= size
2551 i = encodeVarintGenerated(dAtA, i, uint64(size))
2552 }
2553 i--
2554 dAtA[i] = 0x12
2555 }
2556 }
2557 if m.Schema != nil {
2558 {
2559 size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
2560 if err != nil {
2561 return 0, err
2562 }
2563 i -= size
2564 i = encodeVarintGenerated(dAtA, i, uint64(size))
2565 }
2566 i--
2567 dAtA[i] = 0xa
2568 }
2569 return len(dAtA) - i, nil
2570 }
2571
2572 func (m *JSONSchemaPropsOrBool) Marshal() (dAtA []byte, err error) {
2573 size := m.Size()
2574 dAtA = make([]byte, size)
2575 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2576 if err != nil {
2577 return nil, err
2578 }
2579 return dAtA[:n], nil
2580 }
2581
2582 func (m *JSONSchemaPropsOrBool) MarshalTo(dAtA []byte) (int, error) {
2583 size := m.Size()
2584 return m.MarshalToSizedBuffer(dAtA[:size])
2585 }
2586
2587 func (m *JSONSchemaPropsOrBool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2588 i := len(dAtA)
2589 _ = i
2590 var l int
2591 _ = l
2592 if m.Schema != nil {
2593 {
2594 size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
2595 if err != nil {
2596 return 0, err
2597 }
2598 i -= size
2599 i = encodeVarintGenerated(dAtA, i, uint64(size))
2600 }
2601 i--
2602 dAtA[i] = 0x12
2603 }
2604 i--
2605 if m.Allows {
2606 dAtA[i] = 1
2607 } else {
2608 dAtA[i] = 0
2609 }
2610 i--
2611 dAtA[i] = 0x8
2612 return len(dAtA) - i, nil
2613 }
2614
2615 func (m *JSONSchemaPropsOrStringArray) Marshal() (dAtA []byte, err error) {
2616 size := m.Size()
2617 dAtA = make([]byte, size)
2618 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2619 if err != nil {
2620 return nil, err
2621 }
2622 return dAtA[:n], nil
2623 }
2624
2625 func (m *JSONSchemaPropsOrStringArray) MarshalTo(dAtA []byte) (int, error) {
2626 size := m.Size()
2627 return m.MarshalToSizedBuffer(dAtA[:size])
2628 }
2629
2630 func (m *JSONSchemaPropsOrStringArray) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2631 i := len(dAtA)
2632 _ = i
2633 var l int
2634 _ = l
2635 if len(m.Property) > 0 {
2636 for iNdEx := len(m.Property) - 1; iNdEx >= 0; iNdEx-- {
2637 i -= len(m.Property[iNdEx])
2638 copy(dAtA[i:], m.Property[iNdEx])
2639 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Property[iNdEx])))
2640 i--
2641 dAtA[i] = 0x12
2642 }
2643 }
2644 if m.Schema != nil {
2645 {
2646 size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
2647 if err != nil {
2648 return 0, err
2649 }
2650 i -= size
2651 i = encodeVarintGenerated(dAtA, i, uint64(size))
2652 }
2653 i--
2654 dAtA[i] = 0xa
2655 }
2656 return len(dAtA) - i, nil
2657 }
2658
2659 func (m *SelectableField) Marshal() (dAtA []byte, err error) {
2660 size := m.Size()
2661 dAtA = make([]byte, size)
2662 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2663 if err != nil {
2664 return nil, err
2665 }
2666 return dAtA[:n], nil
2667 }
2668
2669 func (m *SelectableField) MarshalTo(dAtA []byte) (int, error) {
2670 size := m.Size()
2671 return m.MarshalToSizedBuffer(dAtA[:size])
2672 }
2673
2674 func (m *SelectableField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2675 i := len(dAtA)
2676 _ = i
2677 var l int
2678 _ = l
2679 i -= len(m.JSONPath)
2680 copy(dAtA[i:], m.JSONPath)
2681 i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONPath)))
2682 i--
2683 dAtA[i] = 0xa
2684 return len(dAtA) - i, nil
2685 }
2686
2687 func (m *ServiceReference) Marshal() (dAtA []byte, err error) {
2688 size := m.Size()
2689 dAtA = make([]byte, size)
2690 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2691 if err != nil {
2692 return nil, err
2693 }
2694 return dAtA[:n], nil
2695 }
2696
2697 func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
2698 size := m.Size()
2699 return m.MarshalToSizedBuffer(dAtA[:size])
2700 }
2701
2702 func (m *ServiceReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2703 i := len(dAtA)
2704 _ = i
2705 var l int
2706 _ = l
2707 if m.Port != nil {
2708 i = encodeVarintGenerated(dAtA, i, uint64(*m.Port))
2709 i--
2710 dAtA[i] = 0x20
2711 }
2712 if m.Path != nil {
2713 i -= len(*m.Path)
2714 copy(dAtA[i:], *m.Path)
2715 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Path)))
2716 i--
2717 dAtA[i] = 0x1a
2718 }
2719 i -= len(m.Name)
2720 copy(dAtA[i:], m.Name)
2721 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
2722 i--
2723 dAtA[i] = 0x12
2724 i -= len(m.Namespace)
2725 copy(dAtA[i:], m.Namespace)
2726 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
2727 i--
2728 dAtA[i] = 0xa
2729 return len(dAtA) - i, nil
2730 }
2731
2732 func (m *ValidationRule) Marshal() (dAtA []byte, err error) {
2733 size := m.Size()
2734 dAtA = make([]byte, size)
2735 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2736 if err != nil {
2737 return nil, err
2738 }
2739 return dAtA[:n], nil
2740 }
2741
2742 func (m *ValidationRule) MarshalTo(dAtA []byte) (int, error) {
2743 size := m.Size()
2744 return m.MarshalToSizedBuffer(dAtA[:size])
2745 }
2746
2747 func (m *ValidationRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2748 i := len(dAtA)
2749 _ = i
2750 var l int
2751 _ = l
2752 if m.OptionalOldSelf != nil {
2753 i--
2754 if *m.OptionalOldSelf {
2755 dAtA[i] = 1
2756 } else {
2757 dAtA[i] = 0
2758 }
2759 i--
2760 dAtA[i] = 0x30
2761 }
2762 i -= len(m.FieldPath)
2763 copy(dAtA[i:], m.FieldPath)
2764 i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldPath)))
2765 i--
2766 dAtA[i] = 0x2a
2767 if m.Reason != nil {
2768 i -= len(*m.Reason)
2769 copy(dAtA[i:], *m.Reason)
2770 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Reason)))
2771 i--
2772 dAtA[i] = 0x22
2773 }
2774 i -= len(m.MessageExpression)
2775 copy(dAtA[i:], m.MessageExpression)
2776 i = encodeVarintGenerated(dAtA, i, uint64(len(m.MessageExpression)))
2777 i--
2778 dAtA[i] = 0x1a
2779 i -= len(m.Message)
2780 copy(dAtA[i:], m.Message)
2781 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
2782 i--
2783 dAtA[i] = 0x12
2784 i -= len(m.Rule)
2785 copy(dAtA[i:], m.Rule)
2786 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2787 i--
2788 dAtA[i] = 0xa
2789 return len(dAtA) - i, nil
2790 }
2791
2792 func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) {
2793 size := m.Size()
2794 dAtA = make([]byte, size)
2795 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2796 if err != nil {
2797 return nil, err
2798 }
2799 return dAtA[:n], nil
2800 }
2801
2802 func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
2803 size := m.Size()
2804 return m.MarshalToSizedBuffer(dAtA[:size])
2805 }
2806
2807 func (m *WebhookClientConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2808 i := len(dAtA)
2809 _ = i
2810 var l int
2811 _ = l
2812 if m.URL != nil {
2813 i -= len(*m.URL)
2814 copy(dAtA[i:], *m.URL)
2815 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.URL)))
2816 i--
2817 dAtA[i] = 0x1a
2818 }
2819 if m.CABundle != nil {
2820 i -= len(m.CABundle)
2821 copy(dAtA[i:], m.CABundle)
2822 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CABundle)))
2823 i--
2824 dAtA[i] = 0x12
2825 }
2826 if m.Service != nil {
2827 {
2828 size, err := m.Service.MarshalToSizedBuffer(dAtA[:i])
2829 if err != nil {
2830 return 0, err
2831 }
2832 i -= size
2833 i = encodeVarintGenerated(dAtA, i, uint64(size))
2834 }
2835 i--
2836 dAtA[i] = 0xa
2837 }
2838 return len(dAtA) - i, nil
2839 }
2840
2841 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
2842 offset -= sovGenerated(v)
2843 base := offset
2844 for v >= 1<<7 {
2845 dAtA[offset] = uint8(v&0x7f | 0x80)
2846 v >>= 7
2847 offset++
2848 }
2849 dAtA[offset] = uint8(v)
2850 return base
2851 }
2852 func (m *ConversionRequest) Size() (n int) {
2853 if m == nil {
2854 return 0
2855 }
2856 var l int
2857 _ = l
2858 l = len(m.UID)
2859 n += 1 + l + sovGenerated(uint64(l))
2860 l = len(m.DesiredAPIVersion)
2861 n += 1 + l + sovGenerated(uint64(l))
2862 if len(m.Objects) > 0 {
2863 for _, e := range m.Objects {
2864 l = e.Size()
2865 n += 1 + l + sovGenerated(uint64(l))
2866 }
2867 }
2868 return n
2869 }
2870
2871 func (m *ConversionResponse) Size() (n int) {
2872 if m == nil {
2873 return 0
2874 }
2875 var l int
2876 _ = l
2877 l = len(m.UID)
2878 n += 1 + l + sovGenerated(uint64(l))
2879 if len(m.ConvertedObjects) > 0 {
2880 for _, e := range m.ConvertedObjects {
2881 l = e.Size()
2882 n += 1 + l + sovGenerated(uint64(l))
2883 }
2884 }
2885 l = m.Result.Size()
2886 n += 1 + l + sovGenerated(uint64(l))
2887 return n
2888 }
2889
2890 func (m *ConversionReview) Size() (n int) {
2891 if m == nil {
2892 return 0
2893 }
2894 var l int
2895 _ = l
2896 if m.Request != nil {
2897 l = m.Request.Size()
2898 n += 1 + l + sovGenerated(uint64(l))
2899 }
2900 if m.Response != nil {
2901 l = m.Response.Size()
2902 n += 1 + l + sovGenerated(uint64(l))
2903 }
2904 return n
2905 }
2906
2907 func (m *CustomResourceColumnDefinition) Size() (n int) {
2908 if m == nil {
2909 return 0
2910 }
2911 var l int
2912 _ = l
2913 l = len(m.Name)
2914 n += 1 + l + sovGenerated(uint64(l))
2915 l = len(m.Type)
2916 n += 1 + l + sovGenerated(uint64(l))
2917 l = len(m.Format)
2918 n += 1 + l + sovGenerated(uint64(l))
2919 l = len(m.Description)
2920 n += 1 + l + sovGenerated(uint64(l))
2921 n += 1 + sovGenerated(uint64(m.Priority))
2922 l = len(m.JSONPath)
2923 n += 1 + l + sovGenerated(uint64(l))
2924 return n
2925 }
2926
2927 func (m *CustomResourceConversion) Size() (n int) {
2928 if m == nil {
2929 return 0
2930 }
2931 var l int
2932 _ = l
2933 l = len(m.Strategy)
2934 n += 1 + l + sovGenerated(uint64(l))
2935 if m.WebhookClientConfig != nil {
2936 l = m.WebhookClientConfig.Size()
2937 n += 1 + l + sovGenerated(uint64(l))
2938 }
2939 if len(m.ConversionReviewVersions) > 0 {
2940 for _, s := range m.ConversionReviewVersions {
2941 l = len(s)
2942 n += 1 + l + sovGenerated(uint64(l))
2943 }
2944 }
2945 return n
2946 }
2947
2948 func (m *CustomResourceDefinition) Size() (n int) {
2949 if m == nil {
2950 return 0
2951 }
2952 var l int
2953 _ = l
2954 l = m.ObjectMeta.Size()
2955 n += 1 + l + sovGenerated(uint64(l))
2956 l = m.Spec.Size()
2957 n += 1 + l + sovGenerated(uint64(l))
2958 l = m.Status.Size()
2959 n += 1 + l + sovGenerated(uint64(l))
2960 return n
2961 }
2962
2963 func (m *CustomResourceDefinitionCondition) Size() (n int) {
2964 if m == nil {
2965 return 0
2966 }
2967 var l int
2968 _ = l
2969 l = len(m.Type)
2970 n += 1 + l + sovGenerated(uint64(l))
2971 l = len(m.Status)
2972 n += 1 + l + sovGenerated(uint64(l))
2973 l = m.LastTransitionTime.Size()
2974 n += 1 + l + sovGenerated(uint64(l))
2975 l = len(m.Reason)
2976 n += 1 + l + sovGenerated(uint64(l))
2977 l = len(m.Message)
2978 n += 1 + l + sovGenerated(uint64(l))
2979 return n
2980 }
2981
2982 func (m *CustomResourceDefinitionList) Size() (n int) {
2983 if m == nil {
2984 return 0
2985 }
2986 var l int
2987 _ = l
2988 l = m.ListMeta.Size()
2989 n += 1 + l + sovGenerated(uint64(l))
2990 if len(m.Items) > 0 {
2991 for _, e := range m.Items {
2992 l = e.Size()
2993 n += 1 + l + sovGenerated(uint64(l))
2994 }
2995 }
2996 return n
2997 }
2998
2999 func (m *CustomResourceDefinitionNames) Size() (n int) {
3000 if m == nil {
3001 return 0
3002 }
3003 var l int
3004 _ = l
3005 l = len(m.Plural)
3006 n += 1 + l + sovGenerated(uint64(l))
3007 l = len(m.Singular)
3008 n += 1 + l + sovGenerated(uint64(l))
3009 if len(m.ShortNames) > 0 {
3010 for _, s := range m.ShortNames {
3011 l = len(s)
3012 n += 1 + l + sovGenerated(uint64(l))
3013 }
3014 }
3015 l = len(m.Kind)
3016 n += 1 + l + sovGenerated(uint64(l))
3017 l = len(m.ListKind)
3018 n += 1 + l + sovGenerated(uint64(l))
3019 if len(m.Categories) > 0 {
3020 for _, s := range m.Categories {
3021 l = len(s)
3022 n += 1 + l + sovGenerated(uint64(l))
3023 }
3024 }
3025 return n
3026 }
3027
3028 func (m *CustomResourceDefinitionSpec) Size() (n int) {
3029 if m == nil {
3030 return 0
3031 }
3032 var l int
3033 _ = l
3034 l = len(m.Group)
3035 n += 1 + l + sovGenerated(uint64(l))
3036 l = len(m.Version)
3037 n += 1 + l + sovGenerated(uint64(l))
3038 l = m.Names.Size()
3039 n += 1 + l + sovGenerated(uint64(l))
3040 l = len(m.Scope)
3041 n += 1 + l + sovGenerated(uint64(l))
3042 if m.Validation != nil {
3043 l = m.Validation.Size()
3044 n += 1 + l + sovGenerated(uint64(l))
3045 }
3046 if m.Subresources != nil {
3047 l = m.Subresources.Size()
3048 n += 1 + l + sovGenerated(uint64(l))
3049 }
3050 if len(m.Versions) > 0 {
3051 for _, e := range m.Versions {
3052 l = e.Size()
3053 n += 1 + l + sovGenerated(uint64(l))
3054 }
3055 }
3056 if len(m.AdditionalPrinterColumns) > 0 {
3057 for _, e := range m.AdditionalPrinterColumns {
3058 l = e.Size()
3059 n += 1 + l + sovGenerated(uint64(l))
3060 }
3061 }
3062 if m.Conversion != nil {
3063 l = m.Conversion.Size()
3064 n += 1 + l + sovGenerated(uint64(l))
3065 }
3066 if m.PreserveUnknownFields != nil {
3067 n += 2
3068 }
3069 if len(m.SelectableFields) > 0 {
3070 for _, e := range m.SelectableFields {
3071 l = e.Size()
3072 n += 1 + l + sovGenerated(uint64(l))
3073 }
3074 }
3075 return n
3076 }
3077
3078 func (m *CustomResourceDefinitionStatus) Size() (n int) {
3079 if m == nil {
3080 return 0
3081 }
3082 var l int
3083 _ = l
3084 if len(m.Conditions) > 0 {
3085 for _, e := range m.Conditions {
3086 l = e.Size()
3087 n += 1 + l + sovGenerated(uint64(l))
3088 }
3089 }
3090 l = m.AcceptedNames.Size()
3091 n += 1 + l + sovGenerated(uint64(l))
3092 if len(m.StoredVersions) > 0 {
3093 for _, s := range m.StoredVersions {
3094 l = len(s)
3095 n += 1 + l + sovGenerated(uint64(l))
3096 }
3097 }
3098 return n
3099 }
3100
3101 func (m *CustomResourceDefinitionVersion) Size() (n int) {
3102 if m == nil {
3103 return 0
3104 }
3105 var l int
3106 _ = l
3107 l = len(m.Name)
3108 n += 1 + l + sovGenerated(uint64(l))
3109 n += 2
3110 n += 2
3111 if m.Schema != nil {
3112 l = m.Schema.Size()
3113 n += 1 + l + sovGenerated(uint64(l))
3114 }
3115 if m.Subresources != nil {
3116 l = m.Subresources.Size()
3117 n += 1 + l + sovGenerated(uint64(l))
3118 }
3119 if len(m.AdditionalPrinterColumns) > 0 {
3120 for _, e := range m.AdditionalPrinterColumns {
3121 l = e.Size()
3122 n += 1 + l + sovGenerated(uint64(l))
3123 }
3124 }
3125 n += 2
3126 if m.DeprecationWarning != nil {
3127 l = len(*m.DeprecationWarning)
3128 n += 1 + l + sovGenerated(uint64(l))
3129 }
3130 if len(m.SelectableFields) > 0 {
3131 for _, e := range m.SelectableFields {
3132 l = e.Size()
3133 n += 1 + l + sovGenerated(uint64(l))
3134 }
3135 }
3136 return n
3137 }
3138
3139 func (m *CustomResourceSubresourceScale) Size() (n int) {
3140 if m == nil {
3141 return 0
3142 }
3143 var l int
3144 _ = l
3145 l = len(m.SpecReplicasPath)
3146 n += 1 + l + sovGenerated(uint64(l))
3147 l = len(m.StatusReplicasPath)
3148 n += 1 + l + sovGenerated(uint64(l))
3149 if m.LabelSelectorPath != nil {
3150 l = len(*m.LabelSelectorPath)
3151 n += 1 + l + sovGenerated(uint64(l))
3152 }
3153 return n
3154 }
3155
3156 func (m *CustomResourceSubresourceStatus) Size() (n int) {
3157 if m == nil {
3158 return 0
3159 }
3160 var l int
3161 _ = l
3162 return n
3163 }
3164
3165 func (m *CustomResourceSubresources) Size() (n int) {
3166 if m == nil {
3167 return 0
3168 }
3169 var l int
3170 _ = l
3171 if m.Status != nil {
3172 l = m.Status.Size()
3173 n += 1 + l + sovGenerated(uint64(l))
3174 }
3175 if m.Scale != nil {
3176 l = m.Scale.Size()
3177 n += 1 + l + sovGenerated(uint64(l))
3178 }
3179 return n
3180 }
3181
3182 func (m *CustomResourceValidation) Size() (n int) {
3183 if m == nil {
3184 return 0
3185 }
3186 var l int
3187 _ = l
3188 if m.OpenAPIV3Schema != nil {
3189 l = m.OpenAPIV3Schema.Size()
3190 n += 1 + l + sovGenerated(uint64(l))
3191 }
3192 return n
3193 }
3194
3195 func (m *ExternalDocumentation) Size() (n int) {
3196 if m == nil {
3197 return 0
3198 }
3199 var l int
3200 _ = l
3201 l = len(m.Description)
3202 n += 1 + l + sovGenerated(uint64(l))
3203 l = len(m.URL)
3204 n += 1 + l + sovGenerated(uint64(l))
3205 return n
3206 }
3207
3208 func (m *JSON) Size() (n int) {
3209 if m == nil {
3210 return 0
3211 }
3212 var l int
3213 _ = l
3214 if m.Raw != nil {
3215 l = len(m.Raw)
3216 n += 1 + l + sovGenerated(uint64(l))
3217 }
3218 return n
3219 }
3220
3221 func (m *JSONSchemaProps) Size() (n int) {
3222 if m == nil {
3223 return 0
3224 }
3225 var l int
3226 _ = l
3227 l = len(m.ID)
3228 n += 1 + l + sovGenerated(uint64(l))
3229 l = len(m.Schema)
3230 n += 1 + l + sovGenerated(uint64(l))
3231 if m.Ref != nil {
3232 l = len(*m.Ref)
3233 n += 1 + l + sovGenerated(uint64(l))
3234 }
3235 l = len(m.Description)
3236 n += 1 + l + sovGenerated(uint64(l))
3237 l = len(m.Type)
3238 n += 1 + l + sovGenerated(uint64(l))
3239 l = len(m.Format)
3240 n += 1 + l + sovGenerated(uint64(l))
3241 l = len(m.Title)
3242 n += 1 + l + sovGenerated(uint64(l))
3243 if m.Default != nil {
3244 l = m.Default.Size()
3245 n += 1 + l + sovGenerated(uint64(l))
3246 }
3247 if m.Maximum != nil {
3248 n += 9
3249 }
3250 n += 2
3251 if m.Minimum != nil {
3252 n += 9
3253 }
3254 n += 2
3255 if m.MaxLength != nil {
3256 n += 1 + sovGenerated(uint64(*m.MaxLength))
3257 }
3258 if m.MinLength != nil {
3259 n += 1 + sovGenerated(uint64(*m.MinLength))
3260 }
3261 l = len(m.Pattern)
3262 n += 1 + l + sovGenerated(uint64(l))
3263 if m.MaxItems != nil {
3264 n += 2 + sovGenerated(uint64(*m.MaxItems))
3265 }
3266 if m.MinItems != nil {
3267 n += 2 + sovGenerated(uint64(*m.MinItems))
3268 }
3269 n += 3
3270 if m.MultipleOf != nil {
3271 n += 10
3272 }
3273 if len(m.Enum) > 0 {
3274 for _, e := range m.Enum {
3275 l = e.Size()
3276 n += 2 + l + sovGenerated(uint64(l))
3277 }
3278 }
3279 if m.MaxProperties != nil {
3280 n += 2 + sovGenerated(uint64(*m.MaxProperties))
3281 }
3282 if m.MinProperties != nil {
3283 n += 2 + sovGenerated(uint64(*m.MinProperties))
3284 }
3285 if len(m.Required) > 0 {
3286 for _, s := range m.Required {
3287 l = len(s)
3288 n += 2 + l + sovGenerated(uint64(l))
3289 }
3290 }
3291 if m.Items != nil {
3292 l = m.Items.Size()
3293 n += 2 + l + sovGenerated(uint64(l))
3294 }
3295 if len(m.AllOf) > 0 {
3296 for _, e := range m.AllOf {
3297 l = e.Size()
3298 n += 2 + l + sovGenerated(uint64(l))
3299 }
3300 }
3301 if len(m.OneOf) > 0 {
3302 for _, e := range m.OneOf {
3303 l = e.Size()
3304 n += 2 + l + sovGenerated(uint64(l))
3305 }
3306 }
3307 if len(m.AnyOf) > 0 {
3308 for _, e := range m.AnyOf {
3309 l = e.Size()
3310 n += 2 + l + sovGenerated(uint64(l))
3311 }
3312 }
3313 if m.Not != nil {
3314 l = m.Not.Size()
3315 n += 2 + l + sovGenerated(uint64(l))
3316 }
3317 if len(m.Properties) > 0 {
3318 for k, v := range m.Properties {
3319 _ = k
3320 _ = v
3321 l = v.Size()
3322 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
3323 n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
3324 }
3325 }
3326 if m.AdditionalProperties != nil {
3327 l = m.AdditionalProperties.Size()
3328 n += 2 + l + sovGenerated(uint64(l))
3329 }
3330 if len(m.PatternProperties) > 0 {
3331 for k, v := range m.PatternProperties {
3332 _ = k
3333 _ = v
3334 l = v.Size()
3335 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
3336 n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
3337 }
3338 }
3339 if len(m.Dependencies) > 0 {
3340 for k, v := range m.Dependencies {
3341 _ = k
3342 _ = v
3343 l = v.Size()
3344 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
3345 n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
3346 }
3347 }
3348 if m.AdditionalItems != nil {
3349 l = m.AdditionalItems.Size()
3350 n += 2 + l + sovGenerated(uint64(l))
3351 }
3352 if len(m.Definitions) > 0 {
3353 for k, v := range m.Definitions {
3354 _ = k
3355 _ = v
3356 l = v.Size()
3357 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
3358 n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
3359 }
3360 }
3361 if m.ExternalDocs != nil {
3362 l = m.ExternalDocs.Size()
3363 n += 2 + l + sovGenerated(uint64(l))
3364 }
3365 if m.Example != nil {
3366 l = m.Example.Size()
3367 n += 2 + l + sovGenerated(uint64(l))
3368 }
3369 n += 3
3370 if m.XPreserveUnknownFields != nil {
3371 n += 3
3372 }
3373 n += 3
3374 n += 3
3375 if len(m.XListMapKeys) > 0 {
3376 for _, s := range m.XListMapKeys {
3377 l = len(s)
3378 n += 2 + l + sovGenerated(uint64(l))
3379 }
3380 }
3381 if m.XListType != nil {
3382 l = len(*m.XListType)
3383 n += 2 + l + sovGenerated(uint64(l))
3384 }
3385 if m.XMapType != nil {
3386 l = len(*m.XMapType)
3387 n += 2 + l + sovGenerated(uint64(l))
3388 }
3389 if len(m.XValidations) > 0 {
3390 for _, e := range m.XValidations {
3391 l = e.Size()
3392 n += 2 + l + sovGenerated(uint64(l))
3393 }
3394 }
3395 return n
3396 }
3397
3398 func (m *JSONSchemaPropsOrArray) Size() (n int) {
3399 if m == nil {
3400 return 0
3401 }
3402 var l int
3403 _ = l
3404 if m.Schema != nil {
3405 l = m.Schema.Size()
3406 n += 1 + l + sovGenerated(uint64(l))
3407 }
3408 if len(m.JSONSchemas) > 0 {
3409 for _, e := range m.JSONSchemas {
3410 l = e.Size()
3411 n += 1 + l + sovGenerated(uint64(l))
3412 }
3413 }
3414 return n
3415 }
3416
3417 func (m *JSONSchemaPropsOrBool) Size() (n int) {
3418 if m == nil {
3419 return 0
3420 }
3421 var l int
3422 _ = l
3423 n += 2
3424 if m.Schema != nil {
3425 l = m.Schema.Size()
3426 n += 1 + l + sovGenerated(uint64(l))
3427 }
3428 return n
3429 }
3430
3431 func (m *JSONSchemaPropsOrStringArray) Size() (n int) {
3432 if m == nil {
3433 return 0
3434 }
3435 var l int
3436 _ = l
3437 if m.Schema != nil {
3438 l = m.Schema.Size()
3439 n += 1 + l + sovGenerated(uint64(l))
3440 }
3441 if len(m.Property) > 0 {
3442 for _, s := range m.Property {
3443 l = len(s)
3444 n += 1 + l + sovGenerated(uint64(l))
3445 }
3446 }
3447 return n
3448 }
3449
3450 func (m *SelectableField) Size() (n int) {
3451 if m == nil {
3452 return 0
3453 }
3454 var l int
3455 _ = l
3456 l = len(m.JSONPath)
3457 n += 1 + l + sovGenerated(uint64(l))
3458 return n
3459 }
3460
3461 func (m *ServiceReference) Size() (n int) {
3462 if m == nil {
3463 return 0
3464 }
3465 var l int
3466 _ = l
3467 l = len(m.Namespace)
3468 n += 1 + l + sovGenerated(uint64(l))
3469 l = len(m.Name)
3470 n += 1 + l + sovGenerated(uint64(l))
3471 if m.Path != nil {
3472 l = len(*m.Path)
3473 n += 1 + l + sovGenerated(uint64(l))
3474 }
3475 if m.Port != nil {
3476 n += 1 + sovGenerated(uint64(*m.Port))
3477 }
3478 return n
3479 }
3480
3481 func (m *ValidationRule) Size() (n int) {
3482 if m == nil {
3483 return 0
3484 }
3485 var l int
3486 _ = l
3487 l = len(m.Rule)
3488 n += 1 + l + sovGenerated(uint64(l))
3489 l = len(m.Message)
3490 n += 1 + l + sovGenerated(uint64(l))
3491 l = len(m.MessageExpression)
3492 n += 1 + l + sovGenerated(uint64(l))
3493 if m.Reason != nil {
3494 l = len(*m.Reason)
3495 n += 1 + l + sovGenerated(uint64(l))
3496 }
3497 l = len(m.FieldPath)
3498 n += 1 + l + sovGenerated(uint64(l))
3499 if m.OptionalOldSelf != nil {
3500 n += 2
3501 }
3502 return n
3503 }
3504
3505 func (m *WebhookClientConfig) Size() (n int) {
3506 if m == nil {
3507 return 0
3508 }
3509 var l int
3510 _ = l
3511 if m.Service != nil {
3512 l = m.Service.Size()
3513 n += 1 + l + sovGenerated(uint64(l))
3514 }
3515 if m.CABundle != nil {
3516 l = len(m.CABundle)
3517 n += 1 + l + sovGenerated(uint64(l))
3518 }
3519 if m.URL != nil {
3520 l = len(*m.URL)
3521 n += 1 + l + sovGenerated(uint64(l))
3522 }
3523 return n
3524 }
3525
3526 func sovGenerated(x uint64) (n int) {
3527 return (math_bits.Len64(x|1) + 6) / 7
3528 }
3529 func sozGenerated(x uint64) (n int) {
3530 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3531 }
3532 func (this *ConversionRequest) String() string {
3533 if this == nil {
3534 return "nil"
3535 }
3536 repeatedStringForObjects := "[]RawExtension{"
3537 for _, f := range this.Objects {
3538 repeatedStringForObjects += fmt.Sprintf("%v", f) + ","
3539 }
3540 repeatedStringForObjects += "}"
3541 s := strings.Join([]string{`&ConversionRequest{`,
3542 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
3543 `DesiredAPIVersion:` + fmt.Sprintf("%v", this.DesiredAPIVersion) + `,`,
3544 `Objects:` + repeatedStringForObjects + `,`,
3545 `}`,
3546 }, "")
3547 return s
3548 }
3549 func (this *ConversionResponse) String() string {
3550 if this == nil {
3551 return "nil"
3552 }
3553 repeatedStringForConvertedObjects := "[]RawExtension{"
3554 for _, f := range this.ConvertedObjects {
3555 repeatedStringForConvertedObjects += fmt.Sprintf("%v", f) + ","
3556 }
3557 repeatedStringForConvertedObjects += "}"
3558 s := strings.Join([]string{`&ConversionResponse{`,
3559 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
3560 `ConvertedObjects:` + repeatedStringForConvertedObjects + `,`,
3561 `Result:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Result), "Status", "v1.Status", 1), `&`, ``, 1) + `,`,
3562 `}`,
3563 }, "")
3564 return s
3565 }
3566 func (this *ConversionReview) String() string {
3567 if this == nil {
3568 return "nil"
3569 }
3570 s := strings.Join([]string{`&ConversionReview{`,
3571 `Request:` + strings.Replace(this.Request.String(), "ConversionRequest", "ConversionRequest", 1) + `,`,
3572 `Response:` + strings.Replace(this.Response.String(), "ConversionResponse", "ConversionResponse", 1) + `,`,
3573 `}`,
3574 }, "")
3575 return s
3576 }
3577 func (this *CustomResourceColumnDefinition) String() string {
3578 if this == nil {
3579 return "nil"
3580 }
3581 s := strings.Join([]string{`&CustomResourceColumnDefinition{`,
3582 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3583 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3584 `Format:` + fmt.Sprintf("%v", this.Format) + `,`,
3585 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
3586 `Priority:` + fmt.Sprintf("%v", this.Priority) + `,`,
3587 `JSONPath:` + fmt.Sprintf("%v", this.JSONPath) + `,`,
3588 `}`,
3589 }, "")
3590 return s
3591 }
3592 func (this *CustomResourceConversion) String() string {
3593 if this == nil {
3594 return "nil"
3595 }
3596 s := strings.Join([]string{`&CustomResourceConversion{`,
3597 `Strategy:` + fmt.Sprintf("%v", this.Strategy) + `,`,
3598 `WebhookClientConfig:` + strings.Replace(this.WebhookClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1) + `,`,
3599 `ConversionReviewVersions:` + fmt.Sprintf("%v", this.ConversionReviewVersions) + `,`,
3600 `}`,
3601 }, "")
3602 return s
3603 }
3604 func (this *CustomResourceDefinition) String() string {
3605 if this == nil {
3606 return "nil"
3607 }
3608 s := strings.Join([]string{`&CustomResourceDefinition{`,
3609 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3610 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CustomResourceDefinitionSpec", "CustomResourceDefinitionSpec", 1), `&`, ``, 1) + `,`,
3611 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CustomResourceDefinitionStatus", "CustomResourceDefinitionStatus", 1), `&`, ``, 1) + `,`,
3612 `}`,
3613 }, "")
3614 return s
3615 }
3616 func (this *CustomResourceDefinitionCondition) String() string {
3617 if this == nil {
3618 return "nil"
3619 }
3620 s := strings.Join([]string{`&CustomResourceDefinitionCondition{`,
3621 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3622 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3623 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
3624 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3625 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3626 `}`,
3627 }, "")
3628 return s
3629 }
3630 func (this *CustomResourceDefinitionList) String() string {
3631 if this == nil {
3632 return "nil"
3633 }
3634 repeatedStringForItems := "[]CustomResourceDefinition{"
3635 for _, f := range this.Items {
3636 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CustomResourceDefinition", "CustomResourceDefinition", 1), `&`, ``, 1) + ","
3637 }
3638 repeatedStringForItems += "}"
3639 s := strings.Join([]string{`&CustomResourceDefinitionList{`,
3640 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
3641 `Items:` + repeatedStringForItems + `,`,
3642 `}`,
3643 }, "")
3644 return s
3645 }
3646 func (this *CustomResourceDefinitionNames) String() string {
3647 if this == nil {
3648 return "nil"
3649 }
3650 s := strings.Join([]string{`&CustomResourceDefinitionNames{`,
3651 `Plural:` + fmt.Sprintf("%v", this.Plural) + `,`,
3652 `Singular:` + fmt.Sprintf("%v", this.Singular) + `,`,
3653 `ShortNames:` + fmt.Sprintf("%v", this.ShortNames) + `,`,
3654 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
3655 `ListKind:` + fmt.Sprintf("%v", this.ListKind) + `,`,
3656 `Categories:` + fmt.Sprintf("%v", this.Categories) + `,`,
3657 `}`,
3658 }, "")
3659 return s
3660 }
3661 func (this *CustomResourceDefinitionSpec) String() string {
3662 if this == nil {
3663 return "nil"
3664 }
3665 repeatedStringForVersions := "[]CustomResourceDefinitionVersion{"
3666 for _, f := range this.Versions {
3667 repeatedStringForVersions += strings.Replace(strings.Replace(f.String(), "CustomResourceDefinitionVersion", "CustomResourceDefinitionVersion", 1), `&`, ``, 1) + ","
3668 }
3669 repeatedStringForVersions += "}"
3670 repeatedStringForAdditionalPrinterColumns := "[]CustomResourceColumnDefinition{"
3671 for _, f := range this.AdditionalPrinterColumns {
3672 repeatedStringForAdditionalPrinterColumns += strings.Replace(strings.Replace(f.String(), "CustomResourceColumnDefinition", "CustomResourceColumnDefinition", 1), `&`, ``, 1) + ","
3673 }
3674 repeatedStringForAdditionalPrinterColumns += "}"
3675 repeatedStringForSelectableFields := "[]SelectableField{"
3676 for _, f := range this.SelectableFields {
3677 repeatedStringForSelectableFields += strings.Replace(strings.Replace(f.String(), "SelectableField", "SelectableField", 1), `&`, ``, 1) + ","
3678 }
3679 repeatedStringForSelectableFields += "}"
3680 s := strings.Join([]string{`&CustomResourceDefinitionSpec{`,
3681 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
3682 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
3683 `Names:` + strings.Replace(strings.Replace(this.Names.String(), "CustomResourceDefinitionNames", "CustomResourceDefinitionNames", 1), `&`, ``, 1) + `,`,
3684 `Scope:` + fmt.Sprintf("%v", this.Scope) + `,`,
3685 `Validation:` + strings.Replace(this.Validation.String(), "CustomResourceValidation", "CustomResourceValidation", 1) + `,`,
3686 `Subresources:` + strings.Replace(this.Subresources.String(), "CustomResourceSubresources", "CustomResourceSubresources", 1) + `,`,
3687 `Versions:` + repeatedStringForVersions + `,`,
3688 `AdditionalPrinterColumns:` + repeatedStringForAdditionalPrinterColumns + `,`,
3689 `Conversion:` + strings.Replace(this.Conversion.String(), "CustomResourceConversion", "CustomResourceConversion", 1) + `,`,
3690 `PreserveUnknownFields:` + valueToStringGenerated(this.PreserveUnknownFields) + `,`,
3691 `SelectableFields:` + repeatedStringForSelectableFields + `,`,
3692 `}`,
3693 }, "")
3694 return s
3695 }
3696 func (this *CustomResourceDefinitionStatus) String() string {
3697 if this == nil {
3698 return "nil"
3699 }
3700 repeatedStringForConditions := "[]CustomResourceDefinitionCondition{"
3701 for _, f := range this.Conditions {
3702 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "CustomResourceDefinitionCondition", "CustomResourceDefinitionCondition", 1), `&`, ``, 1) + ","
3703 }
3704 repeatedStringForConditions += "}"
3705 s := strings.Join([]string{`&CustomResourceDefinitionStatus{`,
3706 `Conditions:` + repeatedStringForConditions + `,`,
3707 `AcceptedNames:` + strings.Replace(strings.Replace(this.AcceptedNames.String(), "CustomResourceDefinitionNames", "CustomResourceDefinitionNames", 1), `&`, ``, 1) + `,`,
3708 `StoredVersions:` + fmt.Sprintf("%v", this.StoredVersions) + `,`,
3709 `}`,
3710 }, "")
3711 return s
3712 }
3713 func (this *CustomResourceDefinitionVersion) String() string {
3714 if this == nil {
3715 return "nil"
3716 }
3717 repeatedStringForAdditionalPrinterColumns := "[]CustomResourceColumnDefinition{"
3718 for _, f := range this.AdditionalPrinterColumns {
3719 repeatedStringForAdditionalPrinterColumns += strings.Replace(strings.Replace(f.String(), "CustomResourceColumnDefinition", "CustomResourceColumnDefinition", 1), `&`, ``, 1) + ","
3720 }
3721 repeatedStringForAdditionalPrinterColumns += "}"
3722 repeatedStringForSelectableFields := "[]SelectableField{"
3723 for _, f := range this.SelectableFields {
3724 repeatedStringForSelectableFields += strings.Replace(strings.Replace(f.String(), "SelectableField", "SelectableField", 1), `&`, ``, 1) + ","
3725 }
3726 repeatedStringForSelectableFields += "}"
3727 s := strings.Join([]string{`&CustomResourceDefinitionVersion{`,
3728 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3729 `Served:` + fmt.Sprintf("%v", this.Served) + `,`,
3730 `Storage:` + fmt.Sprintf("%v", this.Storage) + `,`,
3731 `Schema:` + strings.Replace(this.Schema.String(), "CustomResourceValidation", "CustomResourceValidation", 1) + `,`,
3732 `Subresources:` + strings.Replace(this.Subresources.String(), "CustomResourceSubresources", "CustomResourceSubresources", 1) + `,`,
3733 `AdditionalPrinterColumns:` + repeatedStringForAdditionalPrinterColumns + `,`,
3734 `Deprecated:` + fmt.Sprintf("%v", this.Deprecated) + `,`,
3735 `DeprecationWarning:` + valueToStringGenerated(this.DeprecationWarning) + `,`,
3736 `SelectableFields:` + repeatedStringForSelectableFields + `,`,
3737 `}`,
3738 }, "")
3739 return s
3740 }
3741 func (this *CustomResourceSubresourceScale) String() string {
3742 if this == nil {
3743 return "nil"
3744 }
3745 s := strings.Join([]string{`&CustomResourceSubresourceScale{`,
3746 `SpecReplicasPath:` + fmt.Sprintf("%v", this.SpecReplicasPath) + `,`,
3747 `StatusReplicasPath:` + fmt.Sprintf("%v", this.StatusReplicasPath) + `,`,
3748 `LabelSelectorPath:` + valueToStringGenerated(this.LabelSelectorPath) + `,`,
3749 `}`,
3750 }, "")
3751 return s
3752 }
3753 func (this *CustomResourceSubresourceStatus) String() string {
3754 if this == nil {
3755 return "nil"
3756 }
3757 s := strings.Join([]string{`&CustomResourceSubresourceStatus{`,
3758 `}`,
3759 }, "")
3760 return s
3761 }
3762 func (this *CustomResourceSubresources) String() string {
3763 if this == nil {
3764 return "nil"
3765 }
3766 s := strings.Join([]string{`&CustomResourceSubresources{`,
3767 `Status:` + strings.Replace(this.Status.String(), "CustomResourceSubresourceStatus", "CustomResourceSubresourceStatus", 1) + `,`,
3768 `Scale:` + strings.Replace(this.Scale.String(), "CustomResourceSubresourceScale", "CustomResourceSubresourceScale", 1) + `,`,
3769 `}`,
3770 }, "")
3771 return s
3772 }
3773 func (this *CustomResourceValidation) String() string {
3774 if this == nil {
3775 return "nil"
3776 }
3777 s := strings.Join([]string{`&CustomResourceValidation{`,
3778 `OpenAPIV3Schema:` + strings.Replace(this.OpenAPIV3Schema.String(), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
3779 `}`,
3780 }, "")
3781 return s
3782 }
3783 func (this *ExternalDocumentation) String() string {
3784 if this == nil {
3785 return "nil"
3786 }
3787 s := strings.Join([]string{`&ExternalDocumentation{`,
3788 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
3789 `URL:` + fmt.Sprintf("%v", this.URL) + `,`,
3790 `}`,
3791 }, "")
3792 return s
3793 }
3794 func (this *JSON) String() string {
3795 if this == nil {
3796 return "nil"
3797 }
3798 s := strings.Join([]string{`&JSON{`,
3799 `Raw:` + valueToStringGenerated(this.Raw) + `,`,
3800 `}`,
3801 }, "")
3802 return s
3803 }
3804 func (this *JSONSchemaProps) String() string {
3805 if this == nil {
3806 return "nil"
3807 }
3808 repeatedStringForEnum := "[]JSON{"
3809 for _, f := range this.Enum {
3810 repeatedStringForEnum += strings.Replace(strings.Replace(f.String(), "JSON", "JSON", 1), `&`, ``, 1) + ","
3811 }
3812 repeatedStringForEnum += "}"
3813 repeatedStringForAllOf := "[]JSONSchemaProps{"
3814 for _, f := range this.AllOf {
3815 repeatedStringForAllOf += strings.Replace(strings.Replace(f.String(), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + ","
3816 }
3817 repeatedStringForAllOf += "}"
3818 repeatedStringForOneOf := "[]JSONSchemaProps{"
3819 for _, f := range this.OneOf {
3820 repeatedStringForOneOf += strings.Replace(strings.Replace(f.String(), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + ","
3821 }
3822 repeatedStringForOneOf += "}"
3823 repeatedStringForAnyOf := "[]JSONSchemaProps{"
3824 for _, f := range this.AnyOf {
3825 repeatedStringForAnyOf += strings.Replace(strings.Replace(f.String(), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + ","
3826 }
3827 repeatedStringForAnyOf += "}"
3828 repeatedStringForXValidations := "[]ValidationRule{"
3829 for _, f := range this.XValidations {
3830 repeatedStringForXValidations += strings.Replace(strings.Replace(f.String(), "ValidationRule", "ValidationRule", 1), `&`, ``, 1) + ","
3831 }
3832 repeatedStringForXValidations += "}"
3833 keysForProperties := make([]string, 0, len(this.Properties))
3834 for k := range this.Properties {
3835 keysForProperties = append(keysForProperties, k)
3836 }
3837 github_com_gogo_protobuf_sortkeys.Strings(keysForProperties)
3838 mapStringForProperties := "map[string]JSONSchemaProps{"
3839 for _, k := range keysForProperties {
3840 mapStringForProperties += fmt.Sprintf("%v: %v,", k, this.Properties[k])
3841 }
3842 mapStringForProperties += "}"
3843 keysForPatternProperties := make([]string, 0, len(this.PatternProperties))
3844 for k := range this.PatternProperties {
3845 keysForPatternProperties = append(keysForPatternProperties, k)
3846 }
3847 github_com_gogo_protobuf_sortkeys.Strings(keysForPatternProperties)
3848 mapStringForPatternProperties := "map[string]JSONSchemaProps{"
3849 for _, k := range keysForPatternProperties {
3850 mapStringForPatternProperties += fmt.Sprintf("%v: %v,", k, this.PatternProperties[k])
3851 }
3852 mapStringForPatternProperties += "}"
3853 keysForDependencies := make([]string, 0, len(this.Dependencies))
3854 for k := range this.Dependencies {
3855 keysForDependencies = append(keysForDependencies, k)
3856 }
3857 github_com_gogo_protobuf_sortkeys.Strings(keysForDependencies)
3858 mapStringForDependencies := "JSONSchemaDependencies{"
3859 for _, k := range keysForDependencies {
3860 mapStringForDependencies += fmt.Sprintf("%v: %v,", k, this.Dependencies[k])
3861 }
3862 mapStringForDependencies += "}"
3863 keysForDefinitions := make([]string, 0, len(this.Definitions))
3864 for k := range this.Definitions {
3865 keysForDefinitions = append(keysForDefinitions, k)
3866 }
3867 github_com_gogo_protobuf_sortkeys.Strings(keysForDefinitions)
3868 mapStringForDefinitions := "JSONSchemaDefinitions{"
3869 for _, k := range keysForDefinitions {
3870 mapStringForDefinitions += fmt.Sprintf("%v: %v,", k, this.Definitions[k])
3871 }
3872 mapStringForDefinitions += "}"
3873 s := strings.Join([]string{`&JSONSchemaProps{`,
3874 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
3875 `Schema:` + fmt.Sprintf("%v", this.Schema) + `,`,
3876 `Ref:` + valueToStringGenerated(this.Ref) + `,`,
3877 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
3878 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3879 `Format:` + fmt.Sprintf("%v", this.Format) + `,`,
3880 `Title:` + fmt.Sprintf("%v", this.Title) + `,`,
3881 `Default:` + strings.Replace(this.Default.String(), "JSON", "JSON", 1) + `,`,
3882 `Maximum:` + valueToStringGenerated(this.Maximum) + `,`,
3883 `ExclusiveMaximum:` + fmt.Sprintf("%v", this.ExclusiveMaximum) + `,`,
3884 `Minimum:` + valueToStringGenerated(this.Minimum) + `,`,
3885 `ExclusiveMinimum:` + fmt.Sprintf("%v", this.ExclusiveMinimum) + `,`,
3886 `MaxLength:` + valueToStringGenerated(this.MaxLength) + `,`,
3887 `MinLength:` + valueToStringGenerated(this.MinLength) + `,`,
3888 `Pattern:` + fmt.Sprintf("%v", this.Pattern) + `,`,
3889 `MaxItems:` + valueToStringGenerated(this.MaxItems) + `,`,
3890 `MinItems:` + valueToStringGenerated(this.MinItems) + `,`,
3891 `UniqueItems:` + fmt.Sprintf("%v", this.UniqueItems) + `,`,
3892 `MultipleOf:` + valueToStringGenerated(this.MultipleOf) + `,`,
3893 `Enum:` + repeatedStringForEnum + `,`,
3894 `MaxProperties:` + valueToStringGenerated(this.MaxProperties) + `,`,
3895 `MinProperties:` + valueToStringGenerated(this.MinProperties) + `,`,
3896 `Required:` + fmt.Sprintf("%v", this.Required) + `,`,
3897 `Items:` + strings.Replace(this.Items.String(), "JSONSchemaPropsOrArray", "JSONSchemaPropsOrArray", 1) + `,`,
3898 `AllOf:` + repeatedStringForAllOf + `,`,
3899 `OneOf:` + repeatedStringForOneOf + `,`,
3900 `AnyOf:` + repeatedStringForAnyOf + `,`,
3901 `Not:` + strings.Replace(this.Not.String(), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
3902 `Properties:` + mapStringForProperties + `,`,
3903 `AdditionalProperties:` + strings.Replace(this.AdditionalProperties.String(), "JSONSchemaPropsOrBool", "JSONSchemaPropsOrBool", 1) + `,`,
3904 `PatternProperties:` + mapStringForPatternProperties + `,`,
3905 `Dependencies:` + mapStringForDependencies + `,`,
3906 `AdditionalItems:` + strings.Replace(this.AdditionalItems.String(), "JSONSchemaPropsOrBool", "JSONSchemaPropsOrBool", 1) + `,`,
3907 `Definitions:` + mapStringForDefinitions + `,`,
3908 `ExternalDocs:` + strings.Replace(this.ExternalDocs.String(), "ExternalDocumentation", "ExternalDocumentation", 1) + `,`,
3909 `Example:` + strings.Replace(this.Example.String(), "JSON", "JSON", 1) + `,`,
3910 `Nullable:` + fmt.Sprintf("%v", this.Nullable) + `,`,
3911 `XPreserveUnknownFields:` + valueToStringGenerated(this.XPreserveUnknownFields) + `,`,
3912 `XEmbeddedResource:` + fmt.Sprintf("%v", this.XEmbeddedResource) + `,`,
3913 `XIntOrString:` + fmt.Sprintf("%v", this.XIntOrString) + `,`,
3914 `XListMapKeys:` + fmt.Sprintf("%v", this.XListMapKeys) + `,`,
3915 `XListType:` + valueToStringGenerated(this.XListType) + `,`,
3916 `XMapType:` + valueToStringGenerated(this.XMapType) + `,`,
3917 `XValidations:` + repeatedStringForXValidations + `,`,
3918 `}`,
3919 }, "")
3920 return s
3921 }
3922 func (this *JSONSchemaPropsOrArray) String() string {
3923 if this == nil {
3924 return "nil"
3925 }
3926 repeatedStringForJSONSchemas := "[]JSONSchemaProps{"
3927 for _, f := range this.JSONSchemas {
3928 repeatedStringForJSONSchemas += strings.Replace(strings.Replace(f.String(), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + ","
3929 }
3930 repeatedStringForJSONSchemas += "}"
3931 s := strings.Join([]string{`&JSONSchemaPropsOrArray{`,
3932 `Schema:` + strings.Replace(this.Schema.String(), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
3933 `JSONSchemas:` + repeatedStringForJSONSchemas + `,`,
3934 `}`,
3935 }, "")
3936 return s
3937 }
3938 func (this *JSONSchemaPropsOrBool) String() string {
3939 if this == nil {
3940 return "nil"
3941 }
3942 s := strings.Join([]string{`&JSONSchemaPropsOrBool{`,
3943 `Allows:` + fmt.Sprintf("%v", this.Allows) + `,`,
3944 `Schema:` + strings.Replace(this.Schema.String(), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
3945 `}`,
3946 }, "")
3947 return s
3948 }
3949 func (this *JSONSchemaPropsOrStringArray) String() string {
3950 if this == nil {
3951 return "nil"
3952 }
3953 s := strings.Join([]string{`&JSONSchemaPropsOrStringArray{`,
3954 `Schema:` + strings.Replace(this.Schema.String(), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`,
3955 `Property:` + fmt.Sprintf("%v", this.Property) + `,`,
3956 `}`,
3957 }, "")
3958 return s
3959 }
3960 func (this *SelectableField) String() string {
3961 if this == nil {
3962 return "nil"
3963 }
3964 s := strings.Join([]string{`&SelectableField{`,
3965 `JSONPath:` + fmt.Sprintf("%v", this.JSONPath) + `,`,
3966 `}`,
3967 }, "")
3968 return s
3969 }
3970 func (this *ServiceReference) String() string {
3971 if this == nil {
3972 return "nil"
3973 }
3974 s := strings.Join([]string{`&ServiceReference{`,
3975 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
3976 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3977 `Path:` + valueToStringGenerated(this.Path) + `,`,
3978 `Port:` + valueToStringGenerated(this.Port) + `,`,
3979 `}`,
3980 }, "")
3981 return s
3982 }
3983 func (this *ValidationRule) String() string {
3984 if this == nil {
3985 return "nil"
3986 }
3987 s := strings.Join([]string{`&ValidationRule{`,
3988 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
3989 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3990 `MessageExpression:` + fmt.Sprintf("%v", this.MessageExpression) + `,`,
3991 `Reason:` + valueToStringGenerated(this.Reason) + `,`,
3992 `FieldPath:` + fmt.Sprintf("%v", this.FieldPath) + `,`,
3993 `OptionalOldSelf:` + valueToStringGenerated(this.OptionalOldSelf) + `,`,
3994 `}`,
3995 }, "")
3996 return s
3997 }
3998 func (this *WebhookClientConfig) String() string {
3999 if this == nil {
4000 return "nil"
4001 }
4002 s := strings.Join([]string{`&WebhookClientConfig{`,
4003 `Service:` + strings.Replace(this.Service.String(), "ServiceReference", "ServiceReference", 1) + `,`,
4004 `CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
4005 `URL:` + valueToStringGenerated(this.URL) + `,`,
4006 `}`,
4007 }, "")
4008 return s
4009 }
4010 func valueToStringGenerated(v interface{}) string {
4011 rv := reflect.ValueOf(v)
4012 if rv.IsNil() {
4013 return "nil"
4014 }
4015 pv := reflect.Indirect(rv).Interface()
4016 return fmt.Sprintf("*%v", pv)
4017 }
4018 func (m *ConversionRequest) Unmarshal(dAtA []byte) error {
4019 l := len(dAtA)
4020 iNdEx := 0
4021 for iNdEx < l {
4022 preIndex := iNdEx
4023 var wire uint64
4024 for shift := uint(0); ; shift += 7 {
4025 if shift >= 64 {
4026 return ErrIntOverflowGenerated
4027 }
4028 if iNdEx >= l {
4029 return io.ErrUnexpectedEOF
4030 }
4031 b := dAtA[iNdEx]
4032 iNdEx++
4033 wire |= uint64(b&0x7F) << shift
4034 if b < 0x80 {
4035 break
4036 }
4037 }
4038 fieldNum := int32(wire >> 3)
4039 wireType := int(wire & 0x7)
4040 if wireType == 4 {
4041 return fmt.Errorf("proto: ConversionRequest: wiretype end group for non-group")
4042 }
4043 if fieldNum <= 0 {
4044 return fmt.Errorf("proto: ConversionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4045 }
4046 switch fieldNum {
4047 case 1:
4048 if wireType != 2 {
4049 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
4050 }
4051 var stringLen uint64
4052 for shift := uint(0); ; shift += 7 {
4053 if shift >= 64 {
4054 return ErrIntOverflowGenerated
4055 }
4056 if iNdEx >= l {
4057 return io.ErrUnexpectedEOF
4058 }
4059 b := dAtA[iNdEx]
4060 iNdEx++
4061 stringLen |= uint64(b&0x7F) << shift
4062 if b < 0x80 {
4063 break
4064 }
4065 }
4066 intStringLen := int(stringLen)
4067 if intStringLen < 0 {
4068 return ErrInvalidLengthGenerated
4069 }
4070 postIndex := iNdEx + intStringLen
4071 if postIndex < 0 {
4072 return ErrInvalidLengthGenerated
4073 }
4074 if postIndex > l {
4075 return io.ErrUnexpectedEOF
4076 }
4077 m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
4078 iNdEx = postIndex
4079 case 2:
4080 if wireType != 2 {
4081 return fmt.Errorf("proto: wrong wireType = %d for field DesiredAPIVersion", wireType)
4082 }
4083 var stringLen uint64
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 stringLen |= uint64(b&0x7F) << shift
4094 if b < 0x80 {
4095 break
4096 }
4097 }
4098 intStringLen := int(stringLen)
4099 if intStringLen < 0 {
4100 return ErrInvalidLengthGenerated
4101 }
4102 postIndex := iNdEx + intStringLen
4103 if postIndex < 0 {
4104 return ErrInvalidLengthGenerated
4105 }
4106 if postIndex > l {
4107 return io.ErrUnexpectedEOF
4108 }
4109 m.DesiredAPIVersion = string(dAtA[iNdEx:postIndex])
4110 iNdEx = postIndex
4111 case 3:
4112 if wireType != 2 {
4113 return fmt.Errorf("proto: wrong wireType = %d for field Objects", wireType)
4114 }
4115 var msglen int
4116 for shift := uint(0); ; shift += 7 {
4117 if shift >= 64 {
4118 return ErrIntOverflowGenerated
4119 }
4120 if iNdEx >= l {
4121 return io.ErrUnexpectedEOF
4122 }
4123 b := dAtA[iNdEx]
4124 iNdEx++
4125 msglen |= int(b&0x7F) << shift
4126 if b < 0x80 {
4127 break
4128 }
4129 }
4130 if msglen < 0 {
4131 return ErrInvalidLengthGenerated
4132 }
4133 postIndex := iNdEx + msglen
4134 if postIndex < 0 {
4135 return ErrInvalidLengthGenerated
4136 }
4137 if postIndex > l {
4138 return io.ErrUnexpectedEOF
4139 }
4140 m.Objects = append(m.Objects, runtime.RawExtension{})
4141 if err := m.Objects[len(m.Objects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4142 return err
4143 }
4144 iNdEx = postIndex
4145 default:
4146 iNdEx = preIndex
4147 skippy, err := skipGenerated(dAtA[iNdEx:])
4148 if err != nil {
4149 return err
4150 }
4151 if (skippy < 0) || (iNdEx+skippy) < 0 {
4152 return ErrInvalidLengthGenerated
4153 }
4154 if (iNdEx + skippy) > l {
4155 return io.ErrUnexpectedEOF
4156 }
4157 iNdEx += skippy
4158 }
4159 }
4160
4161 if iNdEx > l {
4162 return io.ErrUnexpectedEOF
4163 }
4164 return nil
4165 }
4166 func (m *ConversionResponse) Unmarshal(dAtA []byte) error {
4167 l := len(dAtA)
4168 iNdEx := 0
4169 for iNdEx < l {
4170 preIndex := iNdEx
4171 var wire uint64
4172 for shift := uint(0); ; shift += 7 {
4173 if shift >= 64 {
4174 return ErrIntOverflowGenerated
4175 }
4176 if iNdEx >= l {
4177 return io.ErrUnexpectedEOF
4178 }
4179 b := dAtA[iNdEx]
4180 iNdEx++
4181 wire |= uint64(b&0x7F) << shift
4182 if b < 0x80 {
4183 break
4184 }
4185 }
4186 fieldNum := int32(wire >> 3)
4187 wireType := int(wire & 0x7)
4188 if wireType == 4 {
4189 return fmt.Errorf("proto: ConversionResponse: wiretype end group for non-group")
4190 }
4191 if fieldNum <= 0 {
4192 return fmt.Errorf("proto: ConversionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4193 }
4194 switch fieldNum {
4195 case 1:
4196 if wireType != 2 {
4197 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
4198 }
4199 var stringLen uint64
4200 for shift := uint(0); ; shift += 7 {
4201 if shift >= 64 {
4202 return ErrIntOverflowGenerated
4203 }
4204 if iNdEx >= l {
4205 return io.ErrUnexpectedEOF
4206 }
4207 b := dAtA[iNdEx]
4208 iNdEx++
4209 stringLen |= uint64(b&0x7F) << shift
4210 if b < 0x80 {
4211 break
4212 }
4213 }
4214 intStringLen := int(stringLen)
4215 if intStringLen < 0 {
4216 return ErrInvalidLengthGenerated
4217 }
4218 postIndex := iNdEx + intStringLen
4219 if postIndex < 0 {
4220 return ErrInvalidLengthGenerated
4221 }
4222 if postIndex > l {
4223 return io.ErrUnexpectedEOF
4224 }
4225 m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
4226 iNdEx = postIndex
4227 case 2:
4228 if wireType != 2 {
4229 return fmt.Errorf("proto: wrong wireType = %d for field ConvertedObjects", wireType)
4230 }
4231 var msglen int
4232 for shift := uint(0); ; shift += 7 {
4233 if shift >= 64 {
4234 return ErrIntOverflowGenerated
4235 }
4236 if iNdEx >= l {
4237 return io.ErrUnexpectedEOF
4238 }
4239 b := dAtA[iNdEx]
4240 iNdEx++
4241 msglen |= int(b&0x7F) << shift
4242 if b < 0x80 {
4243 break
4244 }
4245 }
4246 if msglen < 0 {
4247 return ErrInvalidLengthGenerated
4248 }
4249 postIndex := iNdEx + msglen
4250 if postIndex < 0 {
4251 return ErrInvalidLengthGenerated
4252 }
4253 if postIndex > l {
4254 return io.ErrUnexpectedEOF
4255 }
4256 m.ConvertedObjects = append(m.ConvertedObjects, runtime.RawExtension{})
4257 if err := m.ConvertedObjects[len(m.ConvertedObjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4258 return err
4259 }
4260 iNdEx = postIndex
4261 case 3:
4262 if wireType != 2 {
4263 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
4264 }
4265 var msglen int
4266 for shift := uint(0); ; shift += 7 {
4267 if shift >= 64 {
4268 return ErrIntOverflowGenerated
4269 }
4270 if iNdEx >= l {
4271 return io.ErrUnexpectedEOF
4272 }
4273 b := dAtA[iNdEx]
4274 iNdEx++
4275 msglen |= int(b&0x7F) << shift
4276 if b < 0x80 {
4277 break
4278 }
4279 }
4280 if msglen < 0 {
4281 return ErrInvalidLengthGenerated
4282 }
4283 postIndex := iNdEx + msglen
4284 if postIndex < 0 {
4285 return ErrInvalidLengthGenerated
4286 }
4287 if postIndex > l {
4288 return io.ErrUnexpectedEOF
4289 }
4290 if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4291 return err
4292 }
4293 iNdEx = postIndex
4294 default:
4295 iNdEx = preIndex
4296 skippy, err := skipGenerated(dAtA[iNdEx:])
4297 if err != nil {
4298 return err
4299 }
4300 if (skippy < 0) || (iNdEx+skippy) < 0 {
4301 return ErrInvalidLengthGenerated
4302 }
4303 if (iNdEx + skippy) > l {
4304 return io.ErrUnexpectedEOF
4305 }
4306 iNdEx += skippy
4307 }
4308 }
4309
4310 if iNdEx > l {
4311 return io.ErrUnexpectedEOF
4312 }
4313 return nil
4314 }
4315 func (m *ConversionReview) Unmarshal(dAtA []byte) error {
4316 l := len(dAtA)
4317 iNdEx := 0
4318 for iNdEx < l {
4319 preIndex := iNdEx
4320 var wire uint64
4321 for shift := uint(0); ; shift += 7 {
4322 if shift >= 64 {
4323 return ErrIntOverflowGenerated
4324 }
4325 if iNdEx >= l {
4326 return io.ErrUnexpectedEOF
4327 }
4328 b := dAtA[iNdEx]
4329 iNdEx++
4330 wire |= uint64(b&0x7F) << shift
4331 if b < 0x80 {
4332 break
4333 }
4334 }
4335 fieldNum := int32(wire >> 3)
4336 wireType := int(wire & 0x7)
4337 if wireType == 4 {
4338 return fmt.Errorf("proto: ConversionReview: wiretype end group for non-group")
4339 }
4340 if fieldNum <= 0 {
4341 return fmt.Errorf("proto: ConversionReview: illegal tag %d (wire type %d)", fieldNum, wire)
4342 }
4343 switch fieldNum {
4344 case 1:
4345 if wireType != 2 {
4346 return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
4347 }
4348 var msglen int
4349 for shift := uint(0); ; shift += 7 {
4350 if shift >= 64 {
4351 return ErrIntOverflowGenerated
4352 }
4353 if iNdEx >= l {
4354 return io.ErrUnexpectedEOF
4355 }
4356 b := dAtA[iNdEx]
4357 iNdEx++
4358 msglen |= int(b&0x7F) << shift
4359 if b < 0x80 {
4360 break
4361 }
4362 }
4363 if msglen < 0 {
4364 return ErrInvalidLengthGenerated
4365 }
4366 postIndex := iNdEx + msglen
4367 if postIndex < 0 {
4368 return ErrInvalidLengthGenerated
4369 }
4370 if postIndex > l {
4371 return io.ErrUnexpectedEOF
4372 }
4373 if m.Request == nil {
4374 m.Request = &ConversionRequest{}
4375 }
4376 if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4377 return err
4378 }
4379 iNdEx = postIndex
4380 case 2:
4381 if wireType != 2 {
4382 return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
4383 }
4384 var msglen int
4385 for shift := uint(0); ; shift += 7 {
4386 if shift >= 64 {
4387 return ErrIntOverflowGenerated
4388 }
4389 if iNdEx >= l {
4390 return io.ErrUnexpectedEOF
4391 }
4392 b := dAtA[iNdEx]
4393 iNdEx++
4394 msglen |= int(b&0x7F) << shift
4395 if b < 0x80 {
4396 break
4397 }
4398 }
4399 if msglen < 0 {
4400 return ErrInvalidLengthGenerated
4401 }
4402 postIndex := iNdEx + msglen
4403 if postIndex < 0 {
4404 return ErrInvalidLengthGenerated
4405 }
4406 if postIndex > l {
4407 return io.ErrUnexpectedEOF
4408 }
4409 if m.Response == nil {
4410 m.Response = &ConversionResponse{}
4411 }
4412 if err := m.Response.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4413 return err
4414 }
4415 iNdEx = postIndex
4416 default:
4417 iNdEx = preIndex
4418 skippy, err := skipGenerated(dAtA[iNdEx:])
4419 if err != nil {
4420 return err
4421 }
4422 if (skippy < 0) || (iNdEx+skippy) < 0 {
4423 return ErrInvalidLengthGenerated
4424 }
4425 if (iNdEx + skippy) > l {
4426 return io.ErrUnexpectedEOF
4427 }
4428 iNdEx += skippy
4429 }
4430 }
4431
4432 if iNdEx > l {
4433 return io.ErrUnexpectedEOF
4434 }
4435 return nil
4436 }
4437 func (m *CustomResourceColumnDefinition) Unmarshal(dAtA []byte) error {
4438 l := len(dAtA)
4439 iNdEx := 0
4440 for iNdEx < l {
4441 preIndex := iNdEx
4442 var wire uint64
4443 for shift := uint(0); ; shift += 7 {
4444 if shift >= 64 {
4445 return ErrIntOverflowGenerated
4446 }
4447 if iNdEx >= l {
4448 return io.ErrUnexpectedEOF
4449 }
4450 b := dAtA[iNdEx]
4451 iNdEx++
4452 wire |= uint64(b&0x7F) << shift
4453 if b < 0x80 {
4454 break
4455 }
4456 }
4457 fieldNum := int32(wire >> 3)
4458 wireType := int(wire & 0x7)
4459 if wireType == 4 {
4460 return fmt.Errorf("proto: CustomResourceColumnDefinition: wiretype end group for non-group")
4461 }
4462 if fieldNum <= 0 {
4463 return fmt.Errorf("proto: CustomResourceColumnDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
4464 }
4465 switch fieldNum {
4466 case 1:
4467 if wireType != 2 {
4468 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4469 }
4470 var stringLen uint64
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 stringLen |= uint64(b&0x7F) << shift
4481 if b < 0x80 {
4482 break
4483 }
4484 }
4485 intStringLen := int(stringLen)
4486 if intStringLen < 0 {
4487 return ErrInvalidLengthGenerated
4488 }
4489 postIndex := iNdEx + intStringLen
4490 if postIndex < 0 {
4491 return ErrInvalidLengthGenerated
4492 }
4493 if postIndex > l {
4494 return io.ErrUnexpectedEOF
4495 }
4496 m.Name = string(dAtA[iNdEx:postIndex])
4497 iNdEx = postIndex
4498 case 2:
4499 if wireType != 2 {
4500 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4501 }
4502 var stringLen uint64
4503 for shift := uint(0); ; shift += 7 {
4504 if shift >= 64 {
4505 return ErrIntOverflowGenerated
4506 }
4507 if iNdEx >= l {
4508 return io.ErrUnexpectedEOF
4509 }
4510 b := dAtA[iNdEx]
4511 iNdEx++
4512 stringLen |= uint64(b&0x7F) << shift
4513 if b < 0x80 {
4514 break
4515 }
4516 }
4517 intStringLen := int(stringLen)
4518 if intStringLen < 0 {
4519 return ErrInvalidLengthGenerated
4520 }
4521 postIndex := iNdEx + intStringLen
4522 if postIndex < 0 {
4523 return ErrInvalidLengthGenerated
4524 }
4525 if postIndex > l {
4526 return io.ErrUnexpectedEOF
4527 }
4528 m.Type = string(dAtA[iNdEx:postIndex])
4529 iNdEx = postIndex
4530 case 3:
4531 if wireType != 2 {
4532 return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
4533 }
4534 var stringLen uint64
4535 for shift := uint(0); ; shift += 7 {
4536 if shift >= 64 {
4537 return ErrIntOverflowGenerated
4538 }
4539 if iNdEx >= l {
4540 return io.ErrUnexpectedEOF
4541 }
4542 b := dAtA[iNdEx]
4543 iNdEx++
4544 stringLen |= uint64(b&0x7F) << shift
4545 if b < 0x80 {
4546 break
4547 }
4548 }
4549 intStringLen := int(stringLen)
4550 if intStringLen < 0 {
4551 return ErrInvalidLengthGenerated
4552 }
4553 postIndex := iNdEx + intStringLen
4554 if postIndex < 0 {
4555 return ErrInvalidLengthGenerated
4556 }
4557 if postIndex > l {
4558 return io.ErrUnexpectedEOF
4559 }
4560 m.Format = string(dAtA[iNdEx:postIndex])
4561 iNdEx = postIndex
4562 case 4:
4563 if wireType != 2 {
4564 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
4565 }
4566 var stringLen uint64
4567 for shift := uint(0); ; shift += 7 {
4568 if shift >= 64 {
4569 return ErrIntOverflowGenerated
4570 }
4571 if iNdEx >= l {
4572 return io.ErrUnexpectedEOF
4573 }
4574 b := dAtA[iNdEx]
4575 iNdEx++
4576 stringLen |= uint64(b&0x7F) << shift
4577 if b < 0x80 {
4578 break
4579 }
4580 }
4581 intStringLen := int(stringLen)
4582 if intStringLen < 0 {
4583 return ErrInvalidLengthGenerated
4584 }
4585 postIndex := iNdEx + intStringLen
4586 if postIndex < 0 {
4587 return ErrInvalidLengthGenerated
4588 }
4589 if postIndex > l {
4590 return io.ErrUnexpectedEOF
4591 }
4592 m.Description = string(dAtA[iNdEx:postIndex])
4593 iNdEx = postIndex
4594 case 5:
4595 if wireType != 0 {
4596 return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
4597 }
4598 m.Priority = 0
4599 for shift := uint(0); ; shift += 7 {
4600 if shift >= 64 {
4601 return ErrIntOverflowGenerated
4602 }
4603 if iNdEx >= l {
4604 return io.ErrUnexpectedEOF
4605 }
4606 b := dAtA[iNdEx]
4607 iNdEx++
4608 m.Priority |= int32(b&0x7F) << shift
4609 if b < 0x80 {
4610 break
4611 }
4612 }
4613 case 6:
4614 if wireType != 2 {
4615 return fmt.Errorf("proto: wrong wireType = %d for field JSONPath", 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 < 0 {
4638 return ErrInvalidLengthGenerated
4639 }
4640 if postIndex > l {
4641 return io.ErrUnexpectedEOF
4642 }
4643 m.JSONPath = string(dAtA[iNdEx:postIndex])
4644 iNdEx = postIndex
4645 default:
4646 iNdEx = preIndex
4647 skippy, err := skipGenerated(dAtA[iNdEx:])
4648 if err != nil {
4649 return err
4650 }
4651 if (skippy < 0) || (iNdEx+skippy) < 0 {
4652 return ErrInvalidLengthGenerated
4653 }
4654 if (iNdEx + skippy) > l {
4655 return io.ErrUnexpectedEOF
4656 }
4657 iNdEx += skippy
4658 }
4659 }
4660
4661 if iNdEx > l {
4662 return io.ErrUnexpectedEOF
4663 }
4664 return nil
4665 }
4666 func (m *CustomResourceConversion) Unmarshal(dAtA []byte) error {
4667 l := len(dAtA)
4668 iNdEx := 0
4669 for iNdEx < l {
4670 preIndex := iNdEx
4671 var wire uint64
4672 for shift := uint(0); ; shift += 7 {
4673 if shift >= 64 {
4674 return ErrIntOverflowGenerated
4675 }
4676 if iNdEx >= l {
4677 return io.ErrUnexpectedEOF
4678 }
4679 b := dAtA[iNdEx]
4680 iNdEx++
4681 wire |= uint64(b&0x7F) << shift
4682 if b < 0x80 {
4683 break
4684 }
4685 }
4686 fieldNum := int32(wire >> 3)
4687 wireType := int(wire & 0x7)
4688 if wireType == 4 {
4689 return fmt.Errorf("proto: CustomResourceConversion: wiretype end group for non-group")
4690 }
4691 if fieldNum <= 0 {
4692 return fmt.Errorf("proto: CustomResourceConversion: illegal tag %d (wire type %d)", fieldNum, wire)
4693 }
4694 switch fieldNum {
4695 case 1:
4696 if wireType != 2 {
4697 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
4698 }
4699 var stringLen uint64
4700 for shift := uint(0); ; shift += 7 {
4701 if shift >= 64 {
4702 return ErrIntOverflowGenerated
4703 }
4704 if iNdEx >= l {
4705 return io.ErrUnexpectedEOF
4706 }
4707 b := dAtA[iNdEx]
4708 iNdEx++
4709 stringLen |= uint64(b&0x7F) << shift
4710 if b < 0x80 {
4711 break
4712 }
4713 }
4714 intStringLen := int(stringLen)
4715 if intStringLen < 0 {
4716 return ErrInvalidLengthGenerated
4717 }
4718 postIndex := iNdEx + intStringLen
4719 if postIndex < 0 {
4720 return ErrInvalidLengthGenerated
4721 }
4722 if postIndex > l {
4723 return io.ErrUnexpectedEOF
4724 }
4725 m.Strategy = ConversionStrategyType(dAtA[iNdEx:postIndex])
4726 iNdEx = postIndex
4727 case 2:
4728 if wireType != 2 {
4729 return fmt.Errorf("proto: wrong wireType = %d for field WebhookClientConfig", wireType)
4730 }
4731 var msglen int
4732 for shift := uint(0); ; shift += 7 {
4733 if shift >= 64 {
4734 return ErrIntOverflowGenerated
4735 }
4736 if iNdEx >= l {
4737 return io.ErrUnexpectedEOF
4738 }
4739 b := dAtA[iNdEx]
4740 iNdEx++
4741 msglen |= int(b&0x7F) << shift
4742 if b < 0x80 {
4743 break
4744 }
4745 }
4746 if msglen < 0 {
4747 return ErrInvalidLengthGenerated
4748 }
4749 postIndex := iNdEx + msglen
4750 if postIndex < 0 {
4751 return ErrInvalidLengthGenerated
4752 }
4753 if postIndex > l {
4754 return io.ErrUnexpectedEOF
4755 }
4756 if m.WebhookClientConfig == nil {
4757 m.WebhookClientConfig = &WebhookClientConfig{}
4758 }
4759 if err := m.WebhookClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4760 return err
4761 }
4762 iNdEx = postIndex
4763 case 3:
4764 if wireType != 2 {
4765 return fmt.Errorf("proto: wrong wireType = %d for field ConversionReviewVersions", wireType)
4766 }
4767 var stringLen uint64
4768 for shift := uint(0); ; shift += 7 {
4769 if shift >= 64 {
4770 return ErrIntOverflowGenerated
4771 }
4772 if iNdEx >= l {
4773 return io.ErrUnexpectedEOF
4774 }
4775 b := dAtA[iNdEx]
4776 iNdEx++
4777 stringLen |= uint64(b&0x7F) << shift
4778 if b < 0x80 {
4779 break
4780 }
4781 }
4782 intStringLen := int(stringLen)
4783 if intStringLen < 0 {
4784 return ErrInvalidLengthGenerated
4785 }
4786 postIndex := iNdEx + intStringLen
4787 if postIndex < 0 {
4788 return ErrInvalidLengthGenerated
4789 }
4790 if postIndex > l {
4791 return io.ErrUnexpectedEOF
4792 }
4793 m.ConversionReviewVersions = append(m.ConversionReviewVersions, string(dAtA[iNdEx:postIndex]))
4794 iNdEx = postIndex
4795 default:
4796 iNdEx = preIndex
4797 skippy, err := skipGenerated(dAtA[iNdEx:])
4798 if err != nil {
4799 return err
4800 }
4801 if (skippy < 0) || (iNdEx+skippy) < 0 {
4802 return ErrInvalidLengthGenerated
4803 }
4804 if (iNdEx + skippy) > l {
4805 return io.ErrUnexpectedEOF
4806 }
4807 iNdEx += skippy
4808 }
4809 }
4810
4811 if iNdEx > l {
4812 return io.ErrUnexpectedEOF
4813 }
4814 return nil
4815 }
4816 func (m *CustomResourceDefinition) Unmarshal(dAtA []byte) error {
4817 l := len(dAtA)
4818 iNdEx := 0
4819 for iNdEx < l {
4820 preIndex := iNdEx
4821 var wire uint64
4822 for shift := uint(0); ; shift += 7 {
4823 if shift >= 64 {
4824 return ErrIntOverflowGenerated
4825 }
4826 if iNdEx >= l {
4827 return io.ErrUnexpectedEOF
4828 }
4829 b := dAtA[iNdEx]
4830 iNdEx++
4831 wire |= uint64(b&0x7F) << shift
4832 if b < 0x80 {
4833 break
4834 }
4835 }
4836 fieldNum := int32(wire >> 3)
4837 wireType := int(wire & 0x7)
4838 if wireType == 4 {
4839 return fmt.Errorf("proto: CustomResourceDefinition: wiretype end group for non-group")
4840 }
4841 if fieldNum <= 0 {
4842 return fmt.Errorf("proto: CustomResourceDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
4843 }
4844 switch fieldNum {
4845 case 1:
4846 if wireType != 2 {
4847 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4848 }
4849 var msglen int
4850 for shift := uint(0); ; shift += 7 {
4851 if shift >= 64 {
4852 return ErrIntOverflowGenerated
4853 }
4854 if iNdEx >= l {
4855 return io.ErrUnexpectedEOF
4856 }
4857 b := dAtA[iNdEx]
4858 iNdEx++
4859 msglen |= int(b&0x7F) << shift
4860 if b < 0x80 {
4861 break
4862 }
4863 }
4864 if msglen < 0 {
4865 return ErrInvalidLengthGenerated
4866 }
4867 postIndex := iNdEx + msglen
4868 if postIndex < 0 {
4869 return ErrInvalidLengthGenerated
4870 }
4871 if postIndex > l {
4872 return io.ErrUnexpectedEOF
4873 }
4874 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4875 return err
4876 }
4877 iNdEx = postIndex
4878 case 2:
4879 if wireType != 2 {
4880 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4881 }
4882 var msglen int
4883 for shift := uint(0); ; shift += 7 {
4884 if shift >= 64 {
4885 return ErrIntOverflowGenerated
4886 }
4887 if iNdEx >= l {
4888 return io.ErrUnexpectedEOF
4889 }
4890 b := dAtA[iNdEx]
4891 iNdEx++
4892 msglen |= int(b&0x7F) << shift
4893 if b < 0x80 {
4894 break
4895 }
4896 }
4897 if msglen < 0 {
4898 return ErrInvalidLengthGenerated
4899 }
4900 postIndex := iNdEx + msglen
4901 if postIndex < 0 {
4902 return ErrInvalidLengthGenerated
4903 }
4904 if postIndex > l {
4905 return io.ErrUnexpectedEOF
4906 }
4907 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4908 return err
4909 }
4910 iNdEx = postIndex
4911 case 3:
4912 if wireType != 2 {
4913 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4914 }
4915 var msglen int
4916 for shift := uint(0); ; shift += 7 {
4917 if shift >= 64 {
4918 return ErrIntOverflowGenerated
4919 }
4920 if iNdEx >= l {
4921 return io.ErrUnexpectedEOF
4922 }
4923 b := dAtA[iNdEx]
4924 iNdEx++
4925 msglen |= int(b&0x7F) << shift
4926 if b < 0x80 {
4927 break
4928 }
4929 }
4930 if msglen < 0 {
4931 return ErrInvalidLengthGenerated
4932 }
4933 postIndex := iNdEx + msglen
4934 if postIndex < 0 {
4935 return ErrInvalidLengthGenerated
4936 }
4937 if postIndex > l {
4938 return io.ErrUnexpectedEOF
4939 }
4940 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4941 return err
4942 }
4943 iNdEx = postIndex
4944 default:
4945 iNdEx = preIndex
4946 skippy, err := skipGenerated(dAtA[iNdEx:])
4947 if err != nil {
4948 return err
4949 }
4950 if (skippy < 0) || (iNdEx+skippy) < 0 {
4951 return ErrInvalidLengthGenerated
4952 }
4953 if (iNdEx + skippy) > l {
4954 return io.ErrUnexpectedEOF
4955 }
4956 iNdEx += skippy
4957 }
4958 }
4959
4960 if iNdEx > l {
4961 return io.ErrUnexpectedEOF
4962 }
4963 return nil
4964 }
4965 func (m *CustomResourceDefinitionCondition) Unmarshal(dAtA []byte) error {
4966 l := len(dAtA)
4967 iNdEx := 0
4968 for iNdEx < l {
4969 preIndex := iNdEx
4970 var wire uint64
4971 for shift := uint(0); ; shift += 7 {
4972 if shift >= 64 {
4973 return ErrIntOverflowGenerated
4974 }
4975 if iNdEx >= l {
4976 return io.ErrUnexpectedEOF
4977 }
4978 b := dAtA[iNdEx]
4979 iNdEx++
4980 wire |= uint64(b&0x7F) << shift
4981 if b < 0x80 {
4982 break
4983 }
4984 }
4985 fieldNum := int32(wire >> 3)
4986 wireType := int(wire & 0x7)
4987 if wireType == 4 {
4988 return fmt.Errorf("proto: CustomResourceDefinitionCondition: wiretype end group for non-group")
4989 }
4990 if fieldNum <= 0 {
4991 return fmt.Errorf("proto: CustomResourceDefinitionCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4992 }
4993 switch fieldNum {
4994 case 1:
4995 if wireType != 2 {
4996 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4997 }
4998 var stringLen uint64
4999 for shift := uint(0); ; shift += 7 {
5000 if shift >= 64 {
5001 return ErrIntOverflowGenerated
5002 }
5003 if iNdEx >= l {
5004 return io.ErrUnexpectedEOF
5005 }
5006 b := dAtA[iNdEx]
5007 iNdEx++
5008 stringLen |= uint64(b&0x7F) << shift
5009 if b < 0x80 {
5010 break
5011 }
5012 }
5013 intStringLen := int(stringLen)
5014 if intStringLen < 0 {
5015 return ErrInvalidLengthGenerated
5016 }
5017 postIndex := iNdEx + intStringLen
5018 if postIndex < 0 {
5019 return ErrInvalidLengthGenerated
5020 }
5021 if postIndex > l {
5022 return io.ErrUnexpectedEOF
5023 }
5024 m.Type = CustomResourceDefinitionConditionType(dAtA[iNdEx:postIndex])
5025 iNdEx = postIndex
5026 case 2:
5027 if wireType != 2 {
5028 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5029 }
5030 var stringLen uint64
5031 for shift := uint(0); ; shift += 7 {
5032 if shift >= 64 {
5033 return ErrIntOverflowGenerated
5034 }
5035 if iNdEx >= l {
5036 return io.ErrUnexpectedEOF
5037 }
5038 b := dAtA[iNdEx]
5039 iNdEx++
5040 stringLen |= uint64(b&0x7F) << shift
5041 if b < 0x80 {
5042 break
5043 }
5044 }
5045 intStringLen := int(stringLen)
5046 if intStringLen < 0 {
5047 return ErrInvalidLengthGenerated
5048 }
5049 postIndex := iNdEx + intStringLen
5050 if postIndex < 0 {
5051 return ErrInvalidLengthGenerated
5052 }
5053 if postIndex > l {
5054 return io.ErrUnexpectedEOF
5055 }
5056 m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
5057 iNdEx = postIndex
5058 case 3:
5059 if wireType != 2 {
5060 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
5061 }
5062 var msglen int
5063 for shift := uint(0); ; shift += 7 {
5064 if shift >= 64 {
5065 return ErrIntOverflowGenerated
5066 }
5067 if iNdEx >= l {
5068 return io.ErrUnexpectedEOF
5069 }
5070 b := dAtA[iNdEx]
5071 iNdEx++
5072 msglen |= int(b&0x7F) << shift
5073 if b < 0x80 {
5074 break
5075 }
5076 }
5077 if msglen < 0 {
5078 return ErrInvalidLengthGenerated
5079 }
5080 postIndex := iNdEx + msglen
5081 if postIndex < 0 {
5082 return ErrInvalidLengthGenerated
5083 }
5084 if postIndex > l {
5085 return io.ErrUnexpectedEOF
5086 }
5087 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5088 return err
5089 }
5090 iNdEx = postIndex
5091 case 4:
5092 if wireType != 2 {
5093 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5094 }
5095 var stringLen uint64
5096 for shift := uint(0); ; shift += 7 {
5097 if shift >= 64 {
5098 return ErrIntOverflowGenerated
5099 }
5100 if iNdEx >= l {
5101 return io.ErrUnexpectedEOF
5102 }
5103 b := dAtA[iNdEx]
5104 iNdEx++
5105 stringLen |= uint64(b&0x7F) << shift
5106 if b < 0x80 {
5107 break
5108 }
5109 }
5110 intStringLen := int(stringLen)
5111 if intStringLen < 0 {
5112 return ErrInvalidLengthGenerated
5113 }
5114 postIndex := iNdEx + intStringLen
5115 if postIndex < 0 {
5116 return ErrInvalidLengthGenerated
5117 }
5118 if postIndex > l {
5119 return io.ErrUnexpectedEOF
5120 }
5121 m.Reason = string(dAtA[iNdEx:postIndex])
5122 iNdEx = postIndex
5123 case 5:
5124 if wireType != 2 {
5125 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5126 }
5127 var stringLen uint64
5128 for shift := uint(0); ; shift += 7 {
5129 if shift >= 64 {
5130 return ErrIntOverflowGenerated
5131 }
5132 if iNdEx >= l {
5133 return io.ErrUnexpectedEOF
5134 }
5135 b := dAtA[iNdEx]
5136 iNdEx++
5137 stringLen |= uint64(b&0x7F) << shift
5138 if b < 0x80 {
5139 break
5140 }
5141 }
5142 intStringLen := int(stringLen)
5143 if intStringLen < 0 {
5144 return ErrInvalidLengthGenerated
5145 }
5146 postIndex := iNdEx + intStringLen
5147 if postIndex < 0 {
5148 return ErrInvalidLengthGenerated
5149 }
5150 if postIndex > l {
5151 return io.ErrUnexpectedEOF
5152 }
5153 m.Message = string(dAtA[iNdEx:postIndex])
5154 iNdEx = postIndex
5155 default:
5156 iNdEx = preIndex
5157 skippy, err := skipGenerated(dAtA[iNdEx:])
5158 if err != nil {
5159 return err
5160 }
5161 if (skippy < 0) || (iNdEx+skippy) < 0 {
5162 return ErrInvalidLengthGenerated
5163 }
5164 if (iNdEx + skippy) > l {
5165 return io.ErrUnexpectedEOF
5166 }
5167 iNdEx += skippy
5168 }
5169 }
5170
5171 if iNdEx > l {
5172 return io.ErrUnexpectedEOF
5173 }
5174 return nil
5175 }
5176 func (m *CustomResourceDefinitionList) Unmarshal(dAtA []byte) error {
5177 l := len(dAtA)
5178 iNdEx := 0
5179 for iNdEx < l {
5180 preIndex := iNdEx
5181 var wire uint64
5182 for shift := uint(0); ; shift += 7 {
5183 if shift >= 64 {
5184 return ErrIntOverflowGenerated
5185 }
5186 if iNdEx >= l {
5187 return io.ErrUnexpectedEOF
5188 }
5189 b := dAtA[iNdEx]
5190 iNdEx++
5191 wire |= uint64(b&0x7F) << shift
5192 if b < 0x80 {
5193 break
5194 }
5195 }
5196 fieldNum := int32(wire >> 3)
5197 wireType := int(wire & 0x7)
5198 if wireType == 4 {
5199 return fmt.Errorf("proto: CustomResourceDefinitionList: wiretype end group for non-group")
5200 }
5201 if fieldNum <= 0 {
5202 return fmt.Errorf("proto: CustomResourceDefinitionList: illegal tag %d (wire type %d)", fieldNum, wire)
5203 }
5204 switch fieldNum {
5205 case 1:
5206 if wireType != 2 {
5207 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5208 }
5209 var msglen int
5210 for shift := uint(0); ; shift += 7 {
5211 if shift >= 64 {
5212 return ErrIntOverflowGenerated
5213 }
5214 if iNdEx >= l {
5215 return io.ErrUnexpectedEOF
5216 }
5217 b := dAtA[iNdEx]
5218 iNdEx++
5219 msglen |= int(b&0x7F) << shift
5220 if b < 0x80 {
5221 break
5222 }
5223 }
5224 if msglen < 0 {
5225 return ErrInvalidLengthGenerated
5226 }
5227 postIndex := iNdEx + msglen
5228 if postIndex < 0 {
5229 return ErrInvalidLengthGenerated
5230 }
5231 if postIndex > l {
5232 return io.ErrUnexpectedEOF
5233 }
5234 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5235 return err
5236 }
5237 iNdEx = postIndex
5238 case 2:
5239 if wireType != 2 {
5240 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5241 }
5242 var msglen int
5243 for shift := uint(0); ; shift += 7 {
5244 if shift >= 64 {
5245 return ErrIntOverflowGenerated
5246 }
5247 if iNdEx >= l {
5248 return io.ErrUnexpectedEOF
5249 }
5250 b := dAtA[iNdEx]
5251 iNdEx++
5252 msglen |= int(b&0x7F) << shift
5253 if b < 0x80 {
5254 break
5255 }
5256 }
5257 if msglen < 0 {
5258 return ErrInvalidLengthGenerated
5259 }
5260 postIndex := iNdEx + msglen
5261 if postIndex < 0 {
5262 return ErrInvalidLengthGenerated
5263 }
5264 if postIndex > l {
5265 return io.ErrUnexpectedEOF
5266 }
5267 m.Items = append(m.Items, CustomResourceDefinition{})
5268 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5269 return err
5270 }
5271 iNdEx = postIndex
5272 default:
5273 iNdEx = preIndex
5274 skippy, err := skipGenerated(dAtA[iNdEx:])
5275 if err != nil {
5276 return err
5277 }
5278 if (skippy < 0) || (iNdEx+skippy) < 0 {
5279 return ErrInvalidLengthGenerated
5280 }
5281 if (iNdEx + skippy) > l {
5282 return io.ErrUnexpectedEOF
5283 }
5284 iNdEx += skippy
5285 }
5286 }
5287
5288 if iNdEx > l {
5289 return io.ErrUnexpectedEOF
5290 }
5291 return nil
5292 }
5293 func (m *CustomResourceDefinitionNames) Unmarshal(dAtA []byte) error {
5294 l := len(dAtA)
5295 iNdEx := 0
5296 for iNdEx < l {
5297 preIndex := iNdEx
5298 var wire uint64
5299 for shift := uint(0); ; shift += 7 {
5300 if shift >= 64 {
5301 return ErrIntOverflowGenerated
5302 }
5303 if iNdEx >= l {
5304 return io.ErrUnexpectedEOF
5305 }
5306 b := dAtA[iNdEx]
5307 iNdEx++
5308 wire |= uint64(b&0x7F) << shift
5309 if b < 0x80 {
5310 break
5311 }
5312 }
5313 fieldNum := int32(wire >> 3)
5314 wireType := int(wire & 0x7)
5315 if wireType == 4 {
5316 return fmt.Errorf("proto: CustomResourceDefinitionNames: wiretype end group for non-group")
5317 }
5318 if fieldNum <= 0 {
5319 return fmt.Errorf("proto: CustomResourceDefinitionNames: illegal tag %d (wire type %d)", fieldNum, wire)
5320 }
5321 switch fieldNum {
5322 case 1:
5323 if wireType != 2 {
5324 return fmt.Errorf("proto: wrong wireType = %d for field Plural", wireType)
5325 }
5326 var stringLen uint64
5327 for shift := uint(0); ; shift += 7 {
5328 if shift >= 64 {
5329 return ErrIntOverflowGenerated
5330 }
5331 if iNdEx >= l {
5332 return io.ErrUnexpectedEOF
5333 }
5334 b := dAtA[iNdEx]
5335 iNdEx++
5336 stringLen |= uint64(b&0x7F) << shift
5337 if b < 0x80 {
5338 break
5339 }
5340 }
5341 intStringLen := int(stringLen)
5342 if intStringLen < 0 {
5343 return ErrInvalidLengthGenerated
5344 }
5345 postIndex := iNdEx + intStringLen
5346 if postIndex < 0 {
5347 return ErrInvalidLengthGenerated
5348 }
5349 if postIndex > l {
5350 return io.ErrUnexpectedEOF
5351 }
5352 m.Plural = string(dAtA[iNdEx:postIndex])
5353 iNdEx = postIndex
5354 case 2:
5355 if wireType != 2 {
5356 return fmt.Errorf("proto: wrong wireType = %d for field Singular", wireType)
5357 }
5358 var stringLen uint64
5359 for shift := uint(0); ; shift += 7 {
5360 if shift >= 64 {
5361 return ErrIntOverflowGenerated
5362 }
5363 if iNdEx >= l {
5364 return io.ErrUnexpectedEOF
5365 }
5366 b := dAtA[iNdEx]
5367 iNdEx++
5368 stringLen |= uint64(b&0x7F) << shift
5369 if b < 0x80 {
5370 break
5371 }
5372 }
5373 intStringLen := int(stringLen)
5374 if intStringLen < 0 {
5375 return ErrInvalidLengthGenerated
5376 }
5377 postIndex := iNdEx + intStringLen
5378 if postIndex < 0 {
5379 return ErrInvalidLengthGenerated
5380 }
5381 if postIndex > l {
5382 return io.ErrUnexpectedEOF
5383 }
5384 m.Singular = string(dAtA[iNdEx:postIndex])
5385 iNdEx = postIndex
5386 case 3:
5387 if wireType != 2 {
5388 return fmt.Errorf("proto: wrong wireType = %d for field ShortNames", wireType)
5389 }
5390 var stringLen uint64
5391 for shift := uint(0); ; shift += 7 {
5392 if shift >= 64 {
5393 return ErrIntOverflowGenerated
5394 }
5395 if iNdEx >= l {
5396 return io.ErrUnexpectedEOF
5397 }
5398 b := dAtA[iNdEx]
5399 iNdEx++
5400 stringLen |= uint64(b&0x7F) << shift
5401 if b < 0x80 {
5402 break
5403 }
5404 }
5405 intStringLen := int(stringLen)
5406 if intStringLen < 0 {
5407 return ErrInvalidLengthGenerated
5408 }
5409 postIndex := iNdEx + intStringLen
5410 if postIndex < 0 {
5411 return ErrInvalidLengthGenerated
5412 }
5413 if postIndex > l {
5414 return io.ErrUnexpectedEOF
5415 }
5416 m.ShortNames = append(m.ShortNames, string(dAtA[iNdEx:postIndex]))
5417 iNdEx = postIndex
5418 case 4:
5419 if wireType != 2 {
5420 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
5421 }
5422 var stringLen uint64
5423 for shift := uint(0); ; shift += 7 {
5424 if shift >= 64 {
5425 return ErrIntOverflowGenerated
5426 }
5427 if iNdEx >= l {
5428 return io.ErrUnexpectedEOF
5429 }
5430 b := dAtA[iNdEx]
5431 iNdEx++
5432 stringLen |= uint64(b&0x7F) << shift
5433 if b < 0x80 {
5434 break
5435 }
5436 }
5437 intStringLen := int(stringLen)
5438 if intStringLen < 0 {
5439 return ErrInvalidLengthGenerated
5440 }
5441 postIndex := iNdEx + intStringLen
5442 if postIndex < 0 {
5443 return ErrInvalidLengthGenerated
5444 }
5445 if postIndex > l {
5446 return io.ErrUnexpectedEOF
5447 }
5448 m.Kind = string(dAtA[iNdEx:postIndex])
5449 iNdEx = postIndex
5450 case 5:
5451 if wireType != 2 {
5452 return fmt.Errorf("proto: wrong wireType = %d for field ListKind", wireType)
5453 }
5454 var stringLen uint64
5455 for shift := uint(0); ; shift += 7 {
5456 if shift >= 64 {
5457 return ErrIntOverflowGenerated
5458 }
5459 if iNdEx >= l {
5460 return io.ErrUnexpectedEOF
5461 }
5462 b := dAtA[iNdEx]
5463 iNdEx++
5464 stringLen |= uint64(b&0x7F) << shift
5465 if b < 0x80 {
5466 break
5467 }
5468 }
5469 intStringLen := int(stringLen)
5470 if intStringLen < 0 {
5471 return ErrInvalidLengthGenerated
5472 }
5473 postIndex := iNdEx + intStringLen
5474 if postIndex < 0 {
5475 return ErrInvalidLengthGenerated
5476 }
5477 if postIndex > l {
5478 return io.ErrUnexpectedEOF
5479 }
5480 m.ListKind = string(dAtA[iNdEx:postIndex])
5481 iNdEx = postIndex
5482 case 6:
5483 if wireType != 2 {
5484 return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType)
5485 }
5486 var stringLen uint64
5487 for shift := uint(0); ; shift += 7 {
5488 if shift >= 64 {
5489 return ErrIntOverflowGenerated
5490 }
5491 if iNdEx >= l {
5492 return io.ErrUnexpectedEOF
5493 }
5494 b := dAtA[iNdEx]
5495 iNdEx++
5496 stringLen |= uint64(b&0x7F) << shift
5497 if b < 0x80 {
5498 break
5499 }
5500 }
5501 intStringLen := int(stringLen)
5502 if intStringLen < 0 {
5503 return ErrInvalidLengthGenerated
5504 }
5505 postIndex := iNdEx + intStringLen
5506 if postIndex < 0 {
5507 return ErrInvalidLengthGenerated
5508 }
5509 if postIndex > l {
5510 return io.ErrUnexpectedEOF
5511 }
5512 m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex]))
5513 iNdEx = postIndex
5514 default:
5515 iNdEx = preIndex
5516 skippy, err := skipGenerated(dAtA[iNdEx:])
5517 if err != nil {
5518 return err
5519 }
5520 if (skippy < 0) || (iNdEx+skippy) < 0 {
5521 return ErrInvalidLengthGenerated
5522 }
5523 if (iNdEx + skippy) > l {
5524 return io.ErrUnexpectedEOF
5525 }
5526 iNdEx += skippy
5527 }
5528 }
5529
5530 if iNdEx > l {
5531 return io.ErrUnexpectedEOF
5532 }
5533 return nil
5534 }
5535 func (m *CustomResourceDefinitionSpec) Unmarshal(dAtA []byte) error {
5536 l := len(dAtA)
5537 iNdEx := 0
5538 for iNdEx < l {
5539 preIndex := iNdEx
5540 var wire uint64
5541 for shift := uint(0); ; shift += 7 {
5542 if shift >= 64 {
5543 return ErrIntOverflowGenerated
5544 }
5545 if iNdEx >= l {
5546 return io.ErrUnexpectedEOF
5547 }
5548 b := dAtA[iNdEx]
5549 iNdEx++
5550 wire |= uint64(b&0x7F) << shift
5551 if b < 0x80 {
5552 break
5553 }
5554 }
5555 fieldNum := int32(wire >> 3)
5556 wireType := int(wire & 0x7)
5557 if wireType == 4 {
5558 return fmt.Errorf("proto: CustomResourceDefinitionSpec: wiretype end group for non-group")
5559 }
5560 if fieldNum <= 0 {
5561 return fmt.Errorf("proto: CustomResourceDefinitionSpec: illegal tag %d (wire type %d)", fieldNum, wire)
5562 }
5563 switch fieldNum {
5564 case 1:
5565 if wireType != 2 {
5566 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
5567 }
5568 var stringLen uint64
5569 for shift := uint(0); ; shift += 7 {
5570 if shift >= 64 {
5571 return ErrIntOverflowGenerated
5572 }
5573 if iNdEx >= l {
5574 return io.ErrUnexpectedEOF
5575 }
5576 b := dAtA[iNdEx]
5577 iNdEx++
5578 stringLen |= uint64(b&0x7F) << shift
5579 if b < 0x80 {
5580 break
5581 }
5582 }
5583 intStringLen := int(stringLen)
5584 if intStringLen < 0 {
5585 return ErrInvalidLengthGenerated
5586 }
5587 postIndex := iNdEx + intStringLen
5588 if postIndex < 0 {
5589 return ErrInvalidLengthGenerated
5590 }
5591 if postIndex > l {
5592 return io.ErrUnexpectedEOF
5593 }
5594 m.Group = string(dAtA[iNdEx:postIndex])
5595 iNdEx = postIndex
5596 case 2:
5597 if wireType != 2 {
5598 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
5599 }
5600 var stringLen uint64
5601 for shift := uint(0); ; shift += 7 {
5602 if shift >= 64 {
5603 return ErrIntOverflowGenerated
5604 }
5605 if iNdEx >= l {
5606 return io.ErrUnexpectedEOF
5607 }
5608 b := dAtA[iNdEx]
5609 iNdEx++
5610 stringLen |= uint64(b&0x7F) << shift
5611 if b < 0x80 {
5612 break
5613 }
5614 }
5615 intStringLen := int(stringLen)
5616 if intStringLen < 0 {
5617 return ErrInvalidLengthGenerated
5618 }
5619 postIndex := iNdEx + intStringLen
5620 if postIndex < 0 {
5621 return ErrInvalidLengthGenerated
5622 }
5623 if postIndex > l {
5624 return io.ErrUnexpectedEOF
5625 }
5626 m.Version = string(dAtA[iNdEx:postIndex])
5627 iNdEx = postIndex
5628 case 3:
5629 if wireType != 2 {
5630 return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
5631 }
5632 var msglen int
5633 for shift := uint(0); ; shift += 7 {
5634 if shift >= 64 {
5635 return ErrIntOverflowGenerated
5636 }
5637 if iNdEx >= l {
5638 return io.ErrUnexpectedEOF
5639 }
5640 b := dAtA[iNdEx]
5641 iNdEx++
5642 msglen |= int(b&0x7F) << shift
5643 if b < 0x80 {
5644 break
5645 }
5646 }
5647 if msglen < 0 {
5648 return ErrInvalidLengthGenerated
5649 }
5650 postIndex := iNdEx + msglen
5651 if postIndex < 0 {
5652 return ErrInvalidLengthGenerated
5653 }
5654 if postIndex > l {
5655 return io.ErrUnexpectedEOF
5656 }
5657 if err := m.Names.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5658 return err
5659 }
5660 iNdEx = postIndex
5661 case 4:
5662 if wireType != 2 {
5663 return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
5664 }
5665 var stringLen uint64
5666 for shift := uint(0); ; shift += 7 {
5667 if shift >= 64 {
5668 return ErrIntOverflowGenerated
5669 }
5670 if iNdEx >= l {
5671 return io.ErrUnexpectedEOF
5672 }
5673 b := dAtA[iNdEx]
5674 iNdEx++
5675 stringLen |= uint64(b&0x7F) << shift
5676 if b < 0x80 {
5677 break
5678 }
5679 }
5680 intStringLen := int(stringLen)
5681 if intStringLen < 0 {
5682 return ErrInvalidLengthGenerated
5683 }
5684 postIndex := iNdEx + intStringLen
5685 if postIndex < 0 {
5686 return ErrInvalidLengthGenerated
5687 }
5688 if postIndex > l {
5689 return io.ErrUnexpectedEOF
5690 }
5691 m.Scope = ResourceScope(dAtA[iNdEx:postIndex])
5692 iNdEx = postIndex
5693 case 5:
5694 if wireType != 2 {
5695 return fmt.Errorf("proto: wrong wireType = %d for field Validation", wireType)
5696 }
5697 var msglen int
5698 for shift := uint(0); ; shift += 7 {
5699 if shift >= 64 {
5700 return ErrIntOverflowGenerated
5701 }
5702 if iNdEx >= l {
5703 return io.ErrUnexpectedEOF
5704 }
5705 b := dAtA[iNdEx]
5706 iNdEx++
5707 msglen |= int(b&0x7F) << shift
5708 if b < 0x80 {
5709 break
5710 }
5711 }
5712 if msglen < 0 {
5713 return ErrInvalidLengthGenerated
5714 }
5715 postIndex := iNdEx + msglen
5716 if postIndex < 0 {
5717 return ErrInvalidLengthGenerated
5718 }
5719 if postIndex > l {
5720 return io.ErrUnexpectedEOF
5721 }
5722 if m.Validation == nil {
5723 m.Validation = &CustomResourceValidation{}
5724 }
5725 if err := m.Validation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5726 return err
5727 }
5728 iNdEx = postIndex
5729 case 6:
5730 if wireType != 2 {
5731 return fmt.Errorf("proto: wrong wireType = %d for field Subresources", wireType)
5732 }
5733 var msglen int
5734 for shift := uint(0); ; shift += 7 {
5735 if shift >= 64 {
5736 return ErrIntOverflowGenerated
5737 }
5738 if iNdEx >= l {
5739 return io.ErrUnexpectedEOF
5740 }
5741 b := dAtA[iNdEx]
5742 iNdEx++
5743 msglen |= int(b&0x7F) << shift
5744 if b < 0x80 {
5745 break
5746 }
5747 }
5748 if msglen < 0 {
5749 return ErrInvalidLengthGenerated
5750 }
5751 postIndex := iNdEx + msglen
5752 if postIndex < 0 {
5753 return ErrInvalidLengthGenerated
5754 }
5755 if postIndex > l {
5756 return io.ErrUnexpectedEOF
5757 }
5758 if m.Subresources == nil {
5759 m.Subresources = &CustomResourceSubresources{}
5760 }
5761 if err := m.Subresources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5762 return err
5763 }
5764 iNdEx = postIndex
5765 case 7:
5766 if wireType != 2 {
5767 return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
5768 }
5769 var msglen int
5770 for shift := uint(0); ; shift += 7 {
5771 if shift >= 64 {
5772 return ErrIntOverflowGenerated
5773 }
5774 if iNdEx >= l {
5775 return io.ErrUnexpectedEOF
5776 }
5777 b := dAtA[iNdEx]
5778 iNdEx++
5779 msglen |= int(b&0x7F) << shift
5780 if b < 0x80 {
5781 break
5782 }
5783 }
5784 if msglen < 0 {
5785 return ErrInvalidLengthGenerated
5786 }
5787 postIndex := iNdEx + msglen
5788 if postIndex < 0 {
5789 return ErrInvalidLengthGenerated
5790 }
5791 if postIndex > l {
5792 return io.ErrUnexpectedEOF
5793 }
5794 m.Versions = append(m.Versions, CustomResourceDefinitionVersion{})
5795 if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5796 return err
5797 }
5798 iNdEx = postIndex
5799 case 8:
5800 if wireType != 2 {
5801 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalPrinterColumns", wireType)
5802 }
5803 var msglen int
5804 for shift := uint(0); ; shift += 7 {
5805 if shift >= 64 {
5806 return ErrIntOverflowGenerated
5807 }
5808 if iNdEx >= l {
5809 return io.ErrUnexpectedEOF
5810 }
5811 b := dAtA[iNdEx]
5812 iNdEx++
5813 msglen |= int(b&0x7F) << shift
5814 if b < 0x80 {
5815 break
5816 }
5817 }
5818 if msglen < 0 {
5819 return ErrInvalidLengthGenerated
5820 }
5821 postIndex := iNdEx + msglen
5822 if postIndex < 0 {
5823 return ErrInvalidLengthGenerated
5824 }
5825 if postIndex > l {
5826 return io.ErrUnexpectedEOF
5827 }
5828 m.AdditionalPrinterColumns = append(m.AdditionalPrinterColumns, CustomResourceColumnDefinition{})
5829 if err := m.AdditionalPrinterColumns[len(m.AdditionalPrinterColumns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5830 return err
5831 }
5832 iNdEx = postIndex
5833 case 9:
5834 if wireType != 2 {
5835 return fmt.Errorf("proto: wrong wireType = %d for field Conversion", wireType)
5836 }
5837 var msglen int
5838 for shift := uint(0); ; shift += 7 {
5839 if shift >= 64 {
5840 return ErrIntOverflowGenerated
5841 }
5842 if iNdEx >= l {
5843 return io.ErrUnexpectedEOF
5844 }
5845 b := dAtA[iNdEx]
5846 iNdEx++
5847 msglen |= int(b&0x7F) << shift
5848 if b < 0x80 {
5849 break
5850 }
5851 }
5852 if msglen < 0 {
5853 return ErrInvalidLengthGenerated
5854 }
5855 postIndex := iNdEx + msglen
5856 if postIndex < 0 {
5857 return ErrInvalidLengthGenerated
5858 }
5859 if postIndex > l {
5860 return io.ErrUnexpectedEOF
5861 }
5862 if m.Conversion == nil {
5863 m.Conversion = &CustomResourceConversion{}
5864 }
5865 if err := m.Conversion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5866 return err
5867 }
5868 iNdEx = postIndex
5869 case 10:
5870 if wireType != 0 {
5871 return fmt.Errorf("proto: wrong wireType = %d for field PreserveUnknownFields", wireType)
5872 }
5873 var v int
5874 for shift := uint(0); ; shift += 7 {
5875 if shift >= 64 {
5876 return ErrIntOverflowGenerated
5877 }
5878 if iNdEx >= l {
5879 return io.ErrUnexpectedEOF
5880 }
5881 b := dAtA[iNdEx]
5882 iNdEx++
5883 v |= int(b&0x7F) << shift
5884 if b < 0x80 {
5885 break
5886 }
5887 }
5888 b := bool(v != 0)
5889 m.PreserveUnknownFields = &b
5890 case 11:
5891 if wireType != 2 {
5892 return fmt.Errorf("proto: wrong wireType = %d for field SelectableFields", 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 < 0 {
5914 return ErrInvalidLengthGenerated
5915 }
5916 if postIndex > l {
5917 return io.ErrUnexpectedEOF
5918 }
5919 m.SelectableFields = append(m.SelectableFields, SelectableField{})
5920 if err := m.SelectableFields[len(m.SelectableFields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5921 return err
5922 }
5923 iNdEx = postIndex
5924 default:
5925 iNdEx = preIndex
5926 skippy, err := skipGenerated(dAtA[iNdEx:])
5927 if err != nil {
5928 return err
5929 }
5930 if (skippy < 0) || (iNdEx+skippy) < 0 {
5931 return ErrInvalidLengthGenerated
5932 }
5933 if (iNdEx + skippy) > l {
5934 return io.ErrUnexpectedEOF
5935 }
5936 iNdEx += skippy
5937 }
5938 }
5939
5940 if iNdEx > l {
5941 return io.ErrUnexpectedEOF
5942 }
5943 return nil
5944 }
5945 func (m *CustomResourceDefinitionStatus) Unmarshal(dAtA []byte) error {
5946 l := len(dAtA)
5947 iNdEx := 0
5948 for iNdEx < l {
5949 preIndex := iNdEx
5950 var wire uint64
5951 for shift := uint(0); ; shift += 7 {
5952 if shift >= 64 {
5953 return ErrIntOverflowGenerated
5954 }
5955 if iNdEx >= l {
5956 return io.ErrUnexpectedEOF
5957 }
5958 b := dAtA[iNdEx]
5959 iNdEx++
5960 wire |= uint64(b&0x7F) << shift
5961 if b < 0x80 {
5962 break
5963 }
5964 }
5965 fieldNum := int32(wire >> 3)
5966 wireType := int(wire & 0x7)
5967 if wireType == 4 {
5968 return fmt.Errorf("proto: CustomResourceDefinitionStatus: wiretype end group for non-group")
5969 }
5970 if fieldNum <= 0 {
5971 return fmt.Errorf("proto: CustomResourceDefinitionStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5972 }
5973 switch fieldNum {
5974 case 1:
5975 if wireType != 2 {
5976 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
5977 }
5978 var msglen int
5979 for shift := uint(0); ; shift += 7 {
5980 if shift >= 64 {
5981 return ErrIntOverflowGenerated
5982 }
5983 if iNdEx >= l {
5984 return io.ErrUnexpectedEOF
5985 }
5986 b := dAtA[iNdEx]
5987 iNdEx++
5988 msglen |= int(b&0x7F) << shift
5989 if b < 0x80 {
5990 break
5991 }
5992 }
5993 if msglen < 0 {
5994 return ErrInvalidLengthGenerated
5995 }
5996 postIndex := iNdEx + msglen
5997 if postIndex < 0 {
5998 return ErrInvalidLengthGenerated
5999 }
6000 if postIndex > l {
6001 return io.ErrUnexpectedEOF
6002 }
6003 m.Conditions = append(m.Conditions, CustomResourceDefinitionCondition{})
6004 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6005 return err
6006 }
6007 iNdEx = postIndex
6008 case 2:
6009 if wireType != 2 {
6010 return fmt.Errorf("proto: wrong wireType = %d for field AcceptedNames", wireType)
6011 }
6012 var msglen int
6013 for shift := uint(0); ; shift += 7 {
6014 if shift >= 64 {
6015 return ErrIntOverflowGenerated
6016 }
6017 if iNdEx >= l {
6018 return io.ErrUnexpectedEOF
6019 }
6020 b := dAtA[iNdEx]
6021 iNdEx++
6022 msglen |= int(b&0x7F) << shift
6023 if b < 0x80 {
6024 break
6025 }
6026 }
6027 if msglen < 0 {
6028 return ErrInvalidLengthGenerated
6029 }
6030 postIndex := iNdEx + msglen
6031 if postIndex < 0 {
6032 return ErrInvalidLengthGenerated
6033 }
6034 if postIndex > l {
6035 return io.ErrUnexpectedEOF
6036 }
6037 if err := m.AcceptedNames.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6038 return err
6039 }
6040 iNdEx = postIndex
6041 case 3:
6042 if wireType != 2 {
6043 return fmt.Errorf("proto: wrong wireType = %d for field StoredVersions", wireType)
6044 }
6045 var stringLen uint64
6046 for shift := uint(0); ; shift += 7 {
6047 if shift >= 64 {
6048 return ErrIntOverflowGenerated
6049 }
6050 if iNdEx >= l {
6051 return io.ErrUnexpectedEOF
6052 }
6053 b := dAtA[iNdEx]
6054 iNdEx++
6055 stringLen |= uint64(b&0x7F) << shift
6056 if b < 0x80 {
6057 break
6058 }
6059 }
6060 intStringLen := int(stringLen)
6061 if intStringLen < 0 {
6062 return ErrInvalidLengthGenerated
6063 }
6064 postIndex := iNdEx + intStringLen
6065 if postIndex < 0 {
6066 return ErrInvalidLengthGenerated
6067 }
6068 if postIndex > l {
6069 return io.ErrUnexpectedEOF
6070 }
6071 m.StoredVersions = append(m.StoredVersions, string(dAtA[iNdEx:postIndex]))
6072 iNdEx = postIndex
6073 default:
6074 iNdEx = preIndex
6075 skippy, err := skipGenerated(dAtA[iNdEx:])
6076 if err != nil {
6077 return err
6078 }
6079 if (skippy < 0) || (iNdEx+skippy) < 0 {
6080 return ErrInvalidLengthGenerated
6081 }
6082 if (iNdEx + skippy) > l {
6083 return io.ErrUnexpectedEOF
6084 }
6085 iNdEx += skippy
6086 }
6087 }
6088
6089 if iNdEx > l {
6090 return io.ErrUnexpectedEOF
6091 }
6092 return nil
6093 }
6094 func (m *CustomResourceDefinitionVersion) Unmarshal(dAtA []byte) error {
6095 l := len(dAtA)
6096 iNdEx := 0
6097 for iNdEx < l {
6098 preIndex := iNdEx
6099 var wire uint64
6100 for shift := uint(0); ; shift += 7 {
6101 if shift >= 64 {
6102 return ErrIntOverflowGenerated
6103 }
6104 if iNdEx >= l {
6105 return io.ErrUnexpectedEOF
6106 }
6107 b := dAtA[iNdEx]
6108 iNdEx++
6109 wire |= uint64(b&0x7F) << shift
6110 if b < 0x80 {
6111 break
6112 }
6113 }
6114 fieldNum := int32(wire >> 3)
6115 wireType := int(wire & 0x7)
6116 if wireType == 4 {
6117 return fmt.Errorf("proto: CustomResourceDefinitionVersion: wiretype end group for non-group")
6118 }
6119 if fieldNum <= 0 {
6120 return fmt.Errorf("proto: CustomResourceDefinitionVersion: illegal tag %d (wire type %d)", fieldNum, wire)
6121 }
6122 switch fieldNum {
6123 case 1:
6124 if wireType != 2 {
6125 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6126 }
6127 var stringLen uint64
6128 for shift := uint(0); ; shift += 7 {
6129 if shift >= 64 {
6130 return ErrIntOverflowGenerated
6131 }
6132 if iNdEx >= l {
6133 return io.ErrUnexpectedEOF
6134 }
6135 b := dAtA[iNdEx]
6136 iNdEx++
6137 stringLen |= uint64(b&0x7F) << shift
6138 if b < 0x80 {
6139 break
6140 }
6141 }
6142 intStringLen := int(stringLen)
6143 if intStringLen < 0 {
6144 return ErrInvalidLengthGenerated
6145 }
6146 postIndex := iNdEx + intStringLen
6147 if postIndex < 0 {
6148 return ErrInvalidLengthGenerated
6149 }
6150 if postIndex > l {
6151 return io.ErrUnexpectedEOF
6152 }
6153 m.Name = string(dAtA[iNdEx:postIndex])
6154 iNdEx = postIndex
6155 case 2:
6156 if wireType != 0 {
6157 return fmt.Errorf("proto: wrong wireType = %d for field Served", wireType)
6158 }
6159 var v int
6160 for shift := uint(0); ; shift += 7 {
6161 if shift >= 64 {
6162 return ErrIntOverflowGenerated
6163 }
6164 if iNdEx >= l {
6165 return io.ErrUnexpectedEOF
6166 }
6167 b := dAtA[iNdEx]
6168 iNdEx++
6169 v |= int(b&0x7F) << shift
6170 if b < 0x80 {
6171 break
6172 }
6173 }
6174 m.Served = bool(v != 0)
6175 case 3:
6176 if wireType != 0 {
6177 return fmt.Errorf("proto: wrong wireType = %d for field Storage", wireType)
6178 }
6179 var v int
6180 for shift := uint(0); ; shift += 7 {
6181 if shift >= 64 {
6182 return ErrIntOverflowGenerated
6183 }
6184 if iNdEx >= l {
6185 return io.ErrUnexpectedEOF
6186 }
6187 b := dAtA[iNdEx]
6188 iNdEx++
6189 v |= int(b&0x7F) << shift
6190 if b < 0x80 {
6191 break
6192 }
6193 }
6194 m.Storage = bool(v != 0)
6195 case 4:
6196 if wireType != 2 {
6197 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
6198 }
6199 var msglen int
6200 for shift := uint(0); ; shift += 7 {
6201 if shift >= 64 {
6202 return ErrIntOverflowGenerated
6203 }
6204 if iNdEx >= l {
6205 return io.ErrUnexpectedEOF
6206 }
6207 b := dAtA[iNdEx]
6208 iNdEx++
6209 msglen |= int(b&0x7F) << shift
6210 if b < 0x80 {
6211 break
6212 }
6213 }
6214 if msglen < 0 {
6215 return ErrInvalidLengthGenerated
6216 }
6217 postIndex := iNdEx + msglen
6218 if postIndex < 0 {
6219 return ErrInvalidLengthGenerated
6220 }
6221 if postIndex > l {
6222 return io.ErrUnexpectedEOF
6223 }
6224 if m.Schema == nil {
6225 m.Schema = &CustomResourceValidation{}
6226 }
6227 if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6228 return err
6229 }
6230 iNdEx = postIndex
6231 case 5:
6232 if wireType != 2 {
6233 return fmt.Errorf("proto: wrong wireType = %d for field Subresources", wireType)
6234 }
6235 var msglen int
6236 for shift := uint(0); ; shift += 7 {
6237 if shift >= 64 {
6238 return ErrIntOverflowGenerated
6239 }
6240 if iNdEx >= l {
6241 return io.ErrUnexpectedEOF
6242 }
6243 b := dAtA[iNdEx]
6244 iNdEx++
6245 msglen |= int(b&0x7F) << shift
6246 if b < 0x80 {
6247 break
6248 }
6249 }
6250 if msglen < 0 {
6251 return ErrInvalidLengthGenerated
6252 }
6253 postIndex := iNdEx + msglen
6254 if postIndex < 0 {
6255 return ErrInvalidLengthGenerated
6256 }
6257 if postIndex > l {
6258 return io.ErrUnexpectedEOF
6259 }
6260 if m.Subresources == nil {
6261 m.Subresources = &CustomResourceSubresources{}
6262 }
6263 if err := m.Subresources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6264 return err
6265 }
6266 iNdEx = postIndex
6267 case 6:
6268 if wireType != 2 {
6269 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalPrinterColumns", wireType)
6270 }
6271 var msglen int
6272 for shift := uint(0); ; shift += 7 {
6273 if shift >= 64 {
6274 return ErrIntOverflowGenerated
6275 }
6276 if iNdEx >= l {
6277 return io.ErrUnexpectedEOF
6278 }
6279 b := dAtA[iNdEx]
6280 iNdEx++
6281 msglen |= int(b&0x7F) << shift
6282 if b < 0x80 {
6283 break
6284 }
6285 }
6286 if msglen < 0 {
6287 return ErrInvalidLengthGenerated
6288 }
6289 postIndex := iNdEx + msglen
6290 if postIndex < 0 {
6291 return ErrInvalidLengthGenerated
6292 }
6293 if postIndex > l {
6294 return io.ErrUnexpectedEOF
6295 }
6296 m.AdditionalPrinterColumns = append(m.AdditionalPrinterColumns, CustomResourceColumnDefinition{})
6297 if err := m.AdditionalPrinterColumns[len(m.AdditionalPrinterColumns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6298 return err
6299 }
6300 iNdEx = postIndex
6301 case 7:
6302 if wireType != 0 {
6303 return fmt.Errorf("proto: wrong wireType = %d for field Deprecated", wireType)
6304 }
6305 var v int
6306 for shift := uint(0); ; shift += 7 {
6307 if shift >= 64 {
6308 return ErrIntOverflowGenerated
6309 }
6310 if iNdEx >= l {
6311 return io.ErrUnexpectedEOF
6312 }
6313 b := dAtA[iNdEx]
6314 iNdEx++
6315 v |= int(b&0x7F) << shift
6316 if b < 0x80 {
6317 break
6318 }
6319 }
6320 m.Deprecated = bool(v != 0)
6321 case 8:
6322 if wireType != 2 {
6323 return fmt.Errorf("proto: wrong wireType = %d for field DeprecationWarning", wireType)
6324 }
6325 var stringLen uint64
6326 for shift := uint(0); ; shift += 7 {
6327 if shift >= 64 {
6328 return ErrIntOverflowGenerated
6329 }
6330 if iNdEx >= l {
6331 return io.ErrUnexpectedEOF
6332 }
6333 b := dAtA[iNdEx]
6334 iNdEx++
6335 stringLen |= uint64(b&0x7F) << shift
6336 if b < 0x80 {
6337 break
6338 }
6339 }
6340 intStringLen := int(stringLen)
6341 if intStringLen < 0 {
6342 return ErrInvalidLengthGenerated
6343 }
6344 postIndex := iNdEx + intStringLen
6345 if postIndex < 0 {
6346 return ErrInvalidLengthGenerated
6347 }
6348 if postIndex > l {
6349 return io.ErrUnexpectedEOF
6350 }
6351 s := string(dAtA[iNdEx:postIndex])
6352 m.DeprecationWarning = &s
6353 iNdEx = postIndex
6354 case 9:
6355 if wireType != 2 {
6356 return fmt.Errorf("proto: wrong wireType = %d for field SelectableFields", wireType)
6357 }
6358 var msglen int
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 msglen |= int(b&0x7F) << shift
6369 if b < 0x80 {
6370 break
6371 }
6372 }
6373 if msglen < 0 {
6374 return ErrInvalidLengthGenerated
6375 }
6376 postIndex := iNdEx + msglen
6377 if postIndex < 0 {
6378 return ErrInvalidLengthGenerated
6379 }
6380 if postIndex > l {
6381 return io.ErrUnexpectedEOF
6382 }
6383 m.SelectableFields = append(m.SelectableFields, SelectableField{})
6384 if err := m.SelectableFields[len(m.SelectableFields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6385 return err
6386 }
6387 iNdEx = postIndex
6388 default:
6389 iNdEx = preIndex
6390 skippy, err := skipGenerated(dAtA[iNdEx:])
6391 if err != nil {
6392 return err
6393 }
6394 if (skippy < 0) || (iNdEx+skippy) < 0 {
6395 return ErrInvalidLengthGenerated
6396 }
6397 if (iNdEx + skippy) > l {
6398 return io.ErrUnexpectedEOF
6399 }
6400 iNdEx += skippy
6401 }
6402 }
6403
6404 if iNdEx > l {
6405 return io.ErrUnexpectedEOF
6406 }
6407 return nil
6408 }
6409 func (m *CustomResourceSubresourceScale) Unmarshal(dAtA []byte) error {
6410 l := len(dAtA)
6411 iNdEx := 0
6412 for iNdEx < l {
6413 preIndex := iNdEx
6414 var wire uint64
6415 for shift := uint(0); ; shift += 7 {
6416 if shift >= 64 {
6417 return ErrIntOverflowGenerated
6418 }
6419 if iNdEx >= l {
6420 return io.ErrUnexpectedEOF
6421 }
6422 b := dAtA[iNdEx]
6423 iNdEx++
6424 wire |= uint64(b&0x7F) << shift
6425 if b < 0x80 {
6426 break
6427 }
6428 }
6429 fieldNum := int32(wire >> 3)
6430 wireType := int(wire & 0x7)
6431 if wireType == 4 {
6432 return fmt.Errorf("proto: CustomResourceSubresourceScale: wiretype end group for non-group")
6433 }
6434 if fieldNum <= 0 {
6435 return fmt.Errorf("proto: CustomResourceSubresourceScale: illegal tag %d (wire type %d)", fieldNum, wire)
6436 }
6437 switch fieldNum {
6438 case 1:
6439 if wireType != 2 {
6440 return fmt.Errorf("proto: wrong wireType = %d for field SpecReplicasPath", wireType)
6441 }
6442 var stringLen uint64
6443 for shift := uint(0); ; shift += 7 {
6444 if shift >= 64 {
6445 return ErrIntOverflowGenerated
6446 }
6447 if iNdEx >= l {
6448 return io.ErrUnexpectedEOF
6449 }
6450 b := dAtA[iNdEx]
6451 iNdEx++
6452 stringLen |= uint64(b&0x7F) << shift
6453 if b < 0x80 {
6454 break
6455 }
6456 }
6457 intStringLen := int(stringLen)
6458 if intStringLen < 0 {
6459 return ErrInvalidLengthGenerated
6460 }
6461 postIndex := iNdEx + intStringLen
6462 if postIndex < 0 {
6463 return ErrInvalidLengthGenerated
6464 }
6465 if postIndex > l {
6466 return io.ErrUnexpectedEOF
6467 }
6468 m.SpecReplicasPath = string(dAtA[iNdEx:postIndex])
6469 iNdEx = postIndex
6470 case 2:
6471 if wireType != 2 {
6472 return fmt.Errorf("proto: wrong wireType = %d for field StatusReplicasPath", wireType)
6473 }
6474 var stringLen uint64
6475 for shift := uint(0); ; shift += 7 {
6476 if shift >= 64 {
6477 return ErrIntOverflowGenerated
6478 }
6479 if iNdEx >= l {
6480 return io.ErrUnexpectedEOF
6481 }
6482 b := dAtA[iNdEx]
6483 iNdEx++
6484 stringLen |= uint64(b&0x7F) << shift
6485 if b < 0x80 {
6486 break
6487 }
6488 }
6489 intStringLen := int(stringLen)
6490 if intStringLen < 0 {
6491 return ErrInvalidLengthGenerated
6492 }
6493 postIndex := iNdEx + intStringLen
6494 if postIndex < 0 {
6495 return ErrInvalidLengthGenerated
6496 }
6497 if postIndex > l {
6498 return io.ErrUnexpectedEOF
6499 }
6500 m.StatusReplicasPath = string(dAtA[iNdEx:postIndex])
6501 iNdEx = postIndex
6502 case 3:
6503 if wireType != 2 {
6504 return fmt.Errorf("proto: wrong wireType = %d for field LabelSelectorPath", wireType)
6505 }
6506 var stringLen uint64
6507 for shift := uint(0); ; shift += 7 {
6508 if shift >= 64 {
6509 return ErrIntOverflowGenerated
6510 }
6511 if iNdEx >= l {
6512 return io.ErrUnexpectedEOF
6513 }
6514 b := dAtA[iNdEx]
6515 iNdEx++
6516 stringLen |= uint64(b&0x7F) << shift
6517 if b < 0x80 {
6518 break
6519 }
6520 }
6521 intStringLen := int(stringLen)
6522 if intStringLen < 0 {
6523 return ErrInvalidLengthGenerated
6524 }
6525 postIndex := iNdEx + intStringLen
6526 if postIndex < 0 {
6527 return ErrInvalidLengthGenerated
6528 }
6529 if postIndex > l {
6530 return io.ErrUnexpectedEOF
6531 }
6532 s := string(dAtA[iNdEx:postIndex])
6533 m.LabelSelectorPath = &s
6534 iNdEx = postIndex
6535 default:
6536 iNdEx = preIndex
6537 skippy, err := skipGenerated(dAtA[iNdEx:])
6538 if err != nil {
6539 return err
6540 }
6541 if (skippy < 0) || (iNdEx+skippy) < 0 {
6542 return ErrInvalidLengthGenerated
6543 }
6544 if (iNdEx + skippy) > l {
6545 return io.ErrUnexpectedEOF
6546 }
6547 iNdEx += skippy
6548 }
6549 }
6550
6551 if iNdEx > l {
6552 return io.ErrUnexpectedEOF
6553 }
6554 return nil
6555 }
6556 func (m *CustomResourceSubresourceStatus) Unmarshal(dAtA []byte) error {
6557 l := len(dAtA)
6558 iNdEx := 0
6559 for iNdEx < l {
6560 preIndex := iNdEx
6561 var wire uint64
6562 for shift := uint(0); ; shift += 7 {
6563 if shift >= 64 {
6564 return ErrIntOverflowGenerated
6565 }
6566 if iNdEx >= l {
6567 return io.ErrUnexpectedEOF
6568 }
6569 b := dAtA[iNdEx]
6570 iNdEx++
6571 wire |= uint64(b&0x7F) << shift
6572 if b < 0x80 {
6573 break
6574 }
6575 }
6576 fieldNum := int32(wire >> 3)
6577 wireType := int(wire & 0x7)
6578 if wireType == 4 {
6579 return fmt.Errorf("proto: CustomResourceSubresourceStatus: wiretype end group for non-group")
6580 }
6581 if fieldNum <= 0 {
6582 return fmt.Errorf("proto: CustomResourceSubresourceStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6583 }
6584 switch fieldNum {
6585 default:
6586 iNdEx = preIndex
6587 skippy, err := skipGenerated(dAtA[iNdEx:])
6588 if err != nil {
6589 return err
6590 }
6591 if (skippy < 0) || (iNdEx+skippy) < 0 {
6592 return ErrInvalidLengthGenerated
6593 }
6594 if (iNdEx + skippy) > l {
6595 return io.ErrUnexpectedEOF
6596 }
6597 iNdEx += skippy
6598 }
6599 }
6600
6601 if iNdEx > l {
6602 return io.ErrUnexpectedEOF
6603 }
6604 return nil
6605 }
6606 func (m *CustomResourceSubresources) Unmarshal(dAtA []byte) error {
6607 l := len(dAtA)
6608 iNdEx := 0
6609 for iNdEx < l {
6610 preIndex := iNdEx
6611 var wire uint64
6612 for shift := uint(0); ; shift += 7 {
6613 if shift >= 64 {
6614 return ErrIntOverflowGenerated
6615 }
6616 if iNdEx >= l {
6617 return io.ErrUnexpectedEOF
6618 }
6619 b := dAtA[iNdEx]
6620 iNdEx++
6621 wire |= uint64(b&0x7F) << shift
6622 if b < 0x80 {
6623 break
6624 }
6625 }
6626 fieldNum := int32(wire >> 3)
6627 wireType := int(wire & 0x7)
6628 if wireType == 4 {
6629 return fmt.Errorf("proto: CustomResourceSubresources: wiretype end group for non-group")
6630 }
6631 if fieldNum <= 0 {
6632 return fmt.Errorf("proto: CustomResourceSubresources: illegal tag %d (wire type %d)", fieldNum, wire)
6633 }
6634 switch fieldNum {
6635 case 1:
6636 if wireType != 2 {
6637 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
6638 }
6639 var msglen int
6640 for shift := uint(0); ; shift += 7 {
6641 if shift >= 64 {
6642 return ErrIntOverflowGenerated
6643 }
6644 if iNdEx >= l {
6645 return io.ErrUnexpectedEOF
6646 }
6647 b := dAtA[iNdEx]
6648 iNdEx++
6649 msglen |= int(b&0x7F) << shift
6650 if b < 0x80 {
6651 break
6652 }
6653 }
6654 if msglen < 0 {
6655 return ErrInvalidLengthGenerated
6656 }
6657 postIndex := iNdEx + msglen
6658 if postIndex < 0 {
6659 return ErrInvalidLengthGenerated
6660 }
6661 if postIndex > l {
6662 return io.ErrUnexpectedEOF
6663 }
6664 if m.Status == nil {
6665 m.Status = &CustomResourceSubresourceStatus{}
6666 }
6667 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6668 return err
6669 }
6670 iNdEx = postIndex
6671 case 2:
6672 if wireType != 2 {
6673 return fmt.Errorf("proto: wrong wireType = %d for field Scale", wireType)
6674 }
6675 var msglen int
6676 for shift := uint(0); ; shift += 7 {
6677 if shift >= 64 {
6678 return ErrIntOverflowGenerated
6679 }
6680 if iNdEx >= l {
6681 return io.ErrUnexpectedEOF
6682 }
6683 b := dAtA[iNdEx]
6684 iNdEx++
6685 msglen |= int(b&0x7F) << shift
6686 if b < 0x80 {
6687 break
6688 }
6689 }
6690 if msglen < 0 {
6691 return ErrInvalidLengthGenerated
6692 }
6693 postIndex := iNdEx + msglen
6694 if postIndex < 0 {
6695 return ErrInvalidLengthGenerated
6696 }
6697 if postIndex > l {
6698 return io.ErrUnexpectedEOF
6699 }
6700 if m.Scale == nil {
6701 m.Scale = &CustomResourceSubresourceScale{}
6702 }
6703 if err := m.Scale.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6704 return err
6705 }
6706 iNdEx = postIndex
6707 default:
6708 iNdEx = preIndex
6709 skippy, err := skipGenerated(dAtA[iNdEx:])
6710 if err != nil {
6711 return err
6712 }
6713 if (skippy < 0) || (iNdEx+skippy) < 0 {
6714 return ErrInvalidLengthGenerated
6715 }
6716 if (iNdEx + skippy) > l {
6717 return io.ErrUnexpectedEOF
6718 }
6719 iNdEx += skippy
6720 }
6721 }
6722
6723 if iNdEx > l {
6724 return io.ErrUnexpectedEOF
6725 }
6726 return nil
6727 }
6728 func (m *CustomResourceValidation) Unmarshal(dAtA []byte) error {
6729 l := len(dAtA)
6730 iNdEx := 0
6731 for iNdEx < l {
6732 preIndex := iNdEx
6733 var wire uint64
6734 for shift := uint(0); ; shift += 7 {
6735 if shift >= 64 {
6736 return ErrIntOverflowGenerated
6737 }
6738 if iNdEx >= l {
6739 return io.ErrUnexpectedEOF
6740 }
6741 b := dAtA[iNdEx]
6742 iNdEx++
6743 wire |= uint64(b&0x7F) << shift
6744 if b < 0x80 {
6745 break
6746 }
6747 }
6748 fieldNum := int32(wire >> 3)
6749 wireType := int(wire & 0x7)
6750 if wireType == 4 {
6751 return fmt.Errorf("proto: CustomResourceValidation: wiretype end group for non-group")
6752 }
6753 if fieldNum <= 0 {
6754 return fmt.Errorf("proto: CustomResourceValidation: illegal tag %d (wire type %d)", fieldNum, wire)
6755 }
6756 switch fieldNum {
6757 case 1:
6758 if wireType != 2 {
6759 return fmt.Errorf("proto: wrong wireType = %d for field OpenAPIV3Schema", wireType)
6760 }
6761 var msglen int
6762 for shift := uint(0); ; shift += 7 {
6763 if shift >= 64 {
6764 return ErrIntOverflowGenerated
6765 }
6766 if iNdEx >= l {
6767 return io.ErrUnexpectedEOF
6768 }
6769 b := dAtA[iNdEx]
6770 iNdEx++
6771 msglen |= int(b&0x7F) << shift
6772 if b < 0x80 {
6773 break
6774 }
6775 }
6776 if msglen < 0 {
6777 return ErrInvalidLengthGenerated
6778 }
6779 postIndex := iNdEx + msglen
6780 if postIndex < 0 {
6781 return ErrInvalidLengthGenerated
6782 }
6783 if postIndex > l {
6784 return io.ErrUnexpectedEOF
6785 }
6786 if m.OpenAPIV3Schema == nil {
6787 m.OpenAPIV3Schema = &JSONSchemaProps{}
6788 }
6789 if err := m.OpenAPIV3Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6790 return err
6791 }
6792 iNdEx = postIndex
6793 default:
6794 iNdEx = preIndex
6795 skippy, err := skipGenerated(dAtA[iNdEx:])
6796 if err != nil {
6797 return err
6798 }
6799 if (skippy < 0) || (iNdEx+skippy) < 0 {
6800 return ErrInvalidLengthGenerated
6801 }
6802 if (iNdEx + skippy) > l {
6803 return io.ErrUnexpectedEOF
6804 }
6805 iNdEx += skippy
6806 }
6807 }
6808
6809 if iNdEx > l {
6810 return io.ErrUnexpectedEOF
6811 }
6812 return nil
6813 }
6814 func (m *ExternalDocumentation) Unmarshal(dAtA []byte) error {
6815 l := len(dAtA)
6816 iNdEx := 0
6817 for iNdEx < l {
6818 preIndex := iNdEx
6819 var wire uint64
6820 for shift := uint(0); ; shift += 7 {
6821 if shift >= 64 {
6822 return ErrIntOverflowGenerated
6823 }
6824 if iNdEx >= l {
6825 return io.ErrUnexpectedEOF
6826 }
6827 b := dAtA[iNdEx]
6828 iNdEx++
6829 wire |= uint64(b&0x7F) << shift
6830 if b < 0x80 {
6831 break
6832 }
6833 }
6834 fieldNum := int32(wire >> 3)
6835 wireType := int(wire & 0x7)
6836 if wireType == 4 {
6837 return fmt.Errorf("proto: ExternalDocumentation: wiretype end group for non-group")
6838 }
6839 if fieldNum <= 0 {
6840 return fmt.Errorf("proto: ExternalDocumentation: illegal tag %d (wire type %d)", fieldNum, wire)
6841 }
6842 switch fieldNum {
6843 case 1:
6844 if wireType != 2 {
6845 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
6846 }
6847 var stringLen uint64
6848 for shift := uint(0); ; shift += 7 {
6849 if shift >= 64 {
6850 return ErrIntOverflowGenerated
6851 }
6852 if iNdEx >= l {
6853 return io.ErrUnexpectedEOF
6854 }
6855 b := dAtA[iNdEx]
6856 iNdEx++
6857 stringLen |= uint64(b&0x7F) << shift
6858 if b < 0x80 {
6859 break
6860 }
6861 }
6862 intStringLen := int(stringLen)
6863 if intStringLen < 0 {
6864 return ErrInvalidLengthGenerated
6865 }
6866 postIndex := iNdEx + intStringLen
6867 if postIndex < 0 {
6868 return ErrInvalidLengthGenerated
6869 }
6870 if postIndex > l {
6871 return io.ErrUnexpectedEOF
6872 }
6873 m.Description = string(dAtA[iNdEx:postIndex])
6874 iNdEx = postIndex
6875 case 2:
6876 if wireType != 2 {
6877 return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
6878 }
6879 var stringLen uint64
6880 for shift := uint(0); ; shift += 7 {
6881 if shift >= 64 {
6882 return ErrIntOverflowGenerated
6883 }
6884 if iNdEx >= l {
6885 return io.ErrUnexpectedEOF
6886 }
6887 b := dAtA[iNdEx]
6888 iNdEx++
6889 stringLen |= uint64(b&0x7F) << shift
6890 if b < 0x80 {
6891 break
6892 }
6893 }
6894 intStringLen := int(stringLen)
6895 if intStringLen < 0 {
6896 return ErrInvalidLengthGenerated
6897 }
6898 postIndex := iNdEx + intStringLen
6899 if postIndex < 0 {
6900 return ErrInvalidLengthGenerated
6901 }
6902 if postIndex > l {
6903 return io.ErrUnexpectedEOF
6904 }
6905 m.URL = string(dAtA[iNdEx:postIndex])
6906 iNdEx = postIndex
6907 default:
6908 iNdEx = preIndex
6909 skippy, err := skipGenerated(dAtA[iNdEx:])
6910 if err != nil {
6911 return err
6912 }
6913 if (skippy < 0) || (iNdEx+skippy) < 0 {
6914 return ErrInvalidLengthGenerated
6915 }
6916 if (iNdEx + skippy) > l {
6917 return io.ErrUnexpectedEOF
6918 }
6919 iNdEx += skippy
6920 }
6921 }
6922
6923 if iNdEx > l {
6924 return io.ErrUnexpectedEOF
6925 }
6926 return nil
6927 }
6928 func (m *JSON) Unmarshal(dAtA []byte) error {
6929 l := len(dAtA)
6930 iNdEx := 0
6931 for iNdEx < l {
6932 preIndex := iNdEx
6933 var wire uint64
6934 for shift := uint(0); ; shift += 7 {
6935 if shift >= 64 {
6936 return ErrIntOverflowGenerated
6937 }
6938 if iNdEx >= l {
6939 return io.ErrUnexpectedEOF
6940 }
6941 b := dAtA[iNdEx]
6942 iNdEx++
6943 wire |= uint64(b&0x7F) << shift
6944 if b < 0x80 {
6945 break
6946 }
6947 }
6948 fieldNum := int32(wire >> 3)
6949 wireType := int(wire & 0x7)
6950 if wireType == 4 {
6951 return fmt.Errorf("proto: JSON: wiretype end group for non-group")
6952 }
6953 if fieldNum <= 0 {
6954 return fmt.Errorf("proto: JSON: illegal tag %d (wire type %d)", fieldNum, wire)
6955 }
6956 switch fieldNum {
6957 case 1:
6958 if wireType != 2 {
6959 return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
6960 }
6961 var byteLen int
6962 for shift := uint(0); ; shift += 7 {
6963 if shift >= 64 {
6964 return ErrIntOverflowGenerated
6965 }
6966 if iNdEx >= l {
6967 return io.ErrUnexpectedEOF
6968 }
6969 b := dAtA[iNdEx]
6970 iNdEx++
6971 byteLen |= int(b&0x7F) << shift
6972 if b < 0x80 {
6973 break
6974 }
6975 }
6976 if byteLen < 0 {
6977 return ErrInvalidLengthGenerated
6978 }
6979 postIndex := iNdEx + byteLen
6980 if postIndex < 0 {
6981 return ErrInvalidLengthGenerated
6982 }
6983 if postIndex > l {
6984 return io.ErrUnexpectedEOF
6985 }
6986 m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...)
6987 if m.Raw == nil {
6988 m.Raw = []byte{}
6989 }
6990 iNdEx = postIndex
6991 default:
6992 iNdEx = preIndex
6993 skippy, err := skipGenerated(dAtA[iNdEx:])
6994 if err != nil {
6995 return err
6996 }
6997 if (skippy < 0) || (iNdEx+skippy) < 0 {
6998 return ErrInvalidLengthGenerated
6999 }
7000 if (iNdEx + skippy) > l {
7001 return io.ErrUnexpectedEOF
7002 }
7003 iNdEx += skippy
7004 }
7005 }
7006
7007 if iNdEx > l {
7008 return io.ErrUnexpectedEOF
7009 }
7010 return nil
7011 }
7012 func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error {
7013 l := len(dAtA)
7014 iNdEx := 0
7015 for iNdEx < l {
7016 preIndex := iNdEx
7017 var wire uint64
7018 for shift := uint(0); ; shift += 7 {
7019 if shift >= 64 {
7020 return ErrIntOverflowGenerated
7021 }
7022 if iNdEx >= l {
7023 return io.ErrUnexpectedEOF
7024 }
7025 b := dAtA[iNdEx]
7026 iNdEx++
7027 wire |= uint64(b&0x7F) << shift
7028 if b < 0x80 {
7029 break
7030 }
7031 }
7032 fieldNum := int32(wire >> 3)
7033 wireType := int(wire & 0x7)
7034 if wireType == 4 {
7035 return fmt.Errorf("proto: JSONSchemaProps: wiretype end group for non-group")
7036 }
7037 if fieldNum <= 0 {
7038 return fmt.Errorf("proto: JSONSchemaProps: illegal tag %d (wire type %d)", fieldNum, wire)
7039 }
7040 switch fieldNum {
7041 case 1:
7042 if wireType != 2 {
7043 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
7044 }
7045 var stringLen uint64
7046 for shift := uint(0); ; shift += 7 {
7047 if shift >= 64 {
7048 return ErrIntOverflowGenerated
7049 }
7050 if iNdEx >= l {
7051 return io.ErrUnexpectedEOF
7052 }
7053 b := dAtA[iNdEx]
7054 iNdEx++
7055 stringLen |= uint64(b&0x7F) << shift
7056 if b < 0x80 {
7057 break
7058 }
7059 }
7060 intStringLen := int(stringLen)
7061 if intStringLen < 0 {
7062 return ErrInvalidLengthGenerated
7063 }
7064 postIndex := iNdEx + intStringLen
7065 if postIndex < 0 {
7066 return ErrInvalidLengthGenerated
7067 }
7068 if postIndex > l {
7069 return io.ErrUnexpectedEOF
7070 }
7071 m.ID = string(dAtA[iNdEx:postIndex])
7072 iNdEx = postIndex
7073 case 2:
7074 if wireType != 2 {
7075 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
7076 }
7077 var stringLen uint64
7078 for shift := uint(0); ; shift += 7 {
7079 if shift >= 64 {
7080 return ErrIntOverflowGenerated
7081 }
7082 if iNdEx >= l {
7083 return io.ErrUnexpectedEOF
7084 }
7085 b := dAtA[iNdEx]
7086 iNdEx++
7087 stringLen |= uint64(b&0x7F) << shift
7088 if b < 0x80 {
7089 break
7090 }
7091 }
7092 intStringLen := int(stringLen)
7093 if intStringLen < 0 {
7094 return ErrInvalidLengthGenerated
7095 }
7096 postIndex := iNdEx + intStringLen
7097 if postIndex < 0 {
7098 return ErrInvalidLengthGenerated
7099 }
7100 if postIndex > l {
7101 return io.ErrUnexpectedEOF
7102 }
7103 m.Schema = JSONSchemaURL(dAtA[iNdEx:postIndex])
7104 iNdEx = postIndex
7105 case 3:
7106 if wireType != 2 {
7107 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
7108 }
7109 var stringLen uint64
7110 for shift := uint(0); ; shift += 7 {
7111 if shift >= 64 {
7112 return ErrIntOverflowGenerated
7113 }
7114 if iNdEx >= l {
7115 return io.ErrUnexpectedEOF
7116 }
7117 b := dAtA[iNdEx]
7118 iNdEx++
7119 stringLen |= uint64(b&0x7F) << shift
7120 if b < 0x80 {
7121 break
7122 }
7123 }
7124 intStringLen := int(stringLen)
7125 if intStringLen < 0 {
7126 return ErrInvalidLengthGenerated
7127 }
7128 postIndex := iNdEx + intStringLen
7129 if postIndex < 0 {
7130 return ErrInvalidLengthGenerated
7131 }
7132 if postIndex > l {
7133 return io.ErrUnexpectedEOF
7134 }
7135 s := string(dAtA[iNdEx:postIndex])
7136 m.Ref = &s
7137 iNdEx = postIndex
7138 case 4:
7139 if wireType != 2 {
7140 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
7141 }
7142 var stringLen uint64
7143 for shift := uint(0); ; shift += 7 {
7144 if shift >= 64 {
7145 return ErrIntOverflowGenerated
7146 }
7147 if iNdEx >= l {
7148 return io.ErrUnexpectedEOF
7149 }
7150 b := dAtA[iNdEx]
7151 iNdEx++
7152 stringLen |= uint64(b&0x7F) << shift
7153 if b < 0x80 {
7154 break
7155 }
7156 }
7157 intStringLen := int(stringLen)
7158 if intStringLen < 0 {
7159 return ErrInvalidLengthGenerated
7160 }
7161 postIndex := iNdEx + intStringLen
7162 if postIndex < 0 {
7163 return ErrInvalidLengthGenerated
7164 }
7165 if postIndex > l {
7166 return io.ErrUnexpectedEOF
7167 }
7168 m.Description = string(dAtA[iNdEx:postIndex])
7169 iNdEx = postIndex
7170 case 5:
7171 if wireType != 2 {
7172 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7173 }
7174 var stringLen uint64
7175 for shift := uint(0); ; shift += 7 {
7176 if shift >= 64 {
7177 return ErrIntOverflowGenerated
7178 }
7179 if iNdEx >= l {
7180 return io.ErrUnexpectedEOF
7181 }
7182 b := dAtA[iNdEx]
7183 iNdEx++
7184 stringLen |= uint64(b&0x7F) << shift
7185 if b < 0x80 {
7186 break
7187 }
7188 }
7189 intStringLen := int(stringLen)
7190 if intStringLen < 0 {
7191 return ErrInvalidLengthGenerated
7192 }
7193 postIndex := iNdEx + intStringLen
7194 if postIndex < 0 {
7195 return ErrInvalidLengthGenerated
7196 }
7197 if postIndex > l {
7198 return io.ErrUnexpectedEOF
7199 }
7200 m.Type = string(dAtA[iNdEx:postIndex])
7201 iNdEx = postIndex
7202 case 6:
7203 if wireType != 2 {
7204 return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
7205 }
7206 var stringLen uint64
7207 for shift := uint(0); ; shift += 7 {
7208 if shift >= 64 {
7209 return ErrIntOverflowGenerated
7210 }
7211 if iNdEx >= l {
7212 return io.ErrUnexpectedEOF
7213 }
7214 b := dAtA[iNdEx]
7215 iNdEx++
7216 stringLen |= uint64(b&0x7F) << shift
7217 if b < 0x80 {
7218 break
7219 }
7220 }
7221 intStringLen := int(stringLen)
7222 if intStringLen < 0 {
7223 return ErrInvalidLengthGenerated
7224 }
7225 postIndex := iNdEx + intStringLen
7226 if postIndex < 0 {
7227 return ErrInvalidLengthGenerated
7228 }
7229 if postIndex > l {
7230 return io.ErrUnexpectedEOF
7231 }
7232 m.Format = string(dAtA[iNdEx:postIndex])
7233 iNdEx = postIndex
7234 case 7:
7235 if wireType != 2 {
7236 return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
7237 }
7238 var stringLen uint64
7239 for shift := uint(0); ; shift += 7 {
7240 if shift >= 64 {
7241 return ErrIntOverflowGenerated
7242 }
7243 if iNdEx >= l {
7244 return io.ErrUnexpectedEOF
7245 }
7246 b := dAtA[iNdEx]
7247 iNdEx++
7248 stringLen |= uint64(b&0x7F) << shift
7249 if b < 0x80 {
7250 break
7251 }
7252 }
7253 intStringLen := int(stringLen)
7254 if intStringLen < 0 {
7255 return ErrInvalidLengthGenerated
7256 }
7257 postIndex := iNdEx + intStringLen
7258 if postIndex < 0 {
7259 return ErrInvalidLengthGenerated
7260 }
7261 if postIndex > l {
7262 return io.ErrUnexpectedEOF
7263 }
7264 m.Title = string(dAtA[iNdEx:postIndex])
7265 iNdEx = postIndex
7266 case 8:
7267 if wireType != 2 {
7268 return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
7269 }
7270 var msglen int
7271 for shift := uint(0); ; shift += 7 {
7272 if shift >= 64 {
7273 return ErrIntOverflowGenerated
7274 }
7275 if iNdEx >= l {
7276 return io.ErrUnexpectedEOF
7277 }
7278 b := dAtA[iNdEx]
7279 iNdEx++
7280 msglen |= int(b&0x7F) << shift
7281 if b < 0x80 {
7282 break
7283 }
7284 }
7285 if msglen < 0 {
7286 return ErrInvalidLengthGenerated
7287 }
7288 postIndex := iNdEx + msglen
7289 if postIndex < 0 {
7290 return ErrInvalidLengthGenerated
7291 }
7292 if postIndex > l {
7293 return io.ErrUnexpectedEOF
7294 }
7295 if m.Default == nil {
7296 m.Default = &JSON{}
7297 }
7298 if err := m.Default.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7299 return err
7300 }
7301 iNdEx = postIndex
7302 case 9:
7303 if wireType != 1 {
7304 return fmt.Errorf("proto: wrong wireType = %d for field Maximum", wireType)
7305 }
7306 var v uint64
7307 if (iNdEx + 8) > l {
7308 return io.ErrUnexpectedEOF
7309 }
7310 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7311 iNdEx += 8
7312 v2 := float64(math.Float64frombits(v))
7313 m.Maximum = &v2
7314 case 10:
7315 if wireType != 0 {
7316 return fmt.Errorf("proto: wrong wireType = %d for field ExclusiveMaximum", wireType)
7317 }
7318 var v int
7319 for shift := uint(0); ; shift += 7 {
7320 if shift >= 64 {
7321 return ErrIntOverflowGenerated
7322 }
7323 if iNdEx >= l {
7324 return io.ErrUnexpectedEOF
7325 }
7326 b := dAtA[iNdEx]
7327 iNdEx++
7328 v |= int(b&0x7F) << shift
7329 if b < 0x80 {
7330 break
7331 }
7332 }
7333 m.ExclusiveMaximum = bool(v != 0)
7334 case 11:
7335 if wireType != 1 {
7336 return fmt.Errorf("proto: wrong wireType = %d for field Minimum", wireType)
7337 }
7338 var v uint64
7339 if (iNdEx + 8) > l {
7340 return io.ErrUnexpectedEOF
7341 }
7342 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7343 iNdEx += 8
7344 v2 := float64(math.Float64frombits(v))
7345 m.Minimum = &v2
7346 case 12:
7347 if wireType != 0 {
7348 return fmt.Errorf("proto: wrong wireType = %d for field ExclusiveMinimum", wireType)
7349 }
7350 var v int
7351 for shift := uint(0); ; shift += 7 {
7352 if shift >= 64 {
7353 return ErrIntOverflowGenerated
7354 }
7355 if iNdEx >= l {
7356 return io.ErrUnexpectedEOF
7357 }
7358 b := dAtA[iNdEx]
7359 iNdEx++
7360 v |= int(b&0x7F) << shift
7361 if b < 0x80 {
7362 break
7363 }
7364 }
7365 m.ExclusiveMinimum = bool(v != 0)
7366 case 13:
7367 if wireType != 0 {
7368 return fmt.Errorf("proto: wrong wireType = %d for field MaxLength", wireType)
7369 }
7370 var v int64
7371 for shift := uint(0); ; shift += 7 {
7372 if shift >= 64 {
7373 return ErrIntOverflowGenerated
7374 }
7375 if iNdEx >= l {
7376 return io.ErrUnexpectedEOF
7377 }
7378 b := dAtA[iNdEx]
7379 iNdEx++
7380 v |= int64(b&0x7F) << shift
7381 if b < 0x80 {
7382 break
7383 }
7384 }
7385 m.MaxLength = &v
7386 case 14:
7387 if wireType != 0 {
7388 return fmt.Errorf("proto: wrong wireType = %d for field MinLength", wireType)
7389 }
7390 var v int64
7391 for shift := uint(0); ; shift += 7 {
7392 if shift >= 64 {
7393 return ErrIntOverflowGenerated
7394 }
7395 if iNdEx >= l {
7396 return io.ErrUnexpectedEOF
7397 }
7398 b := dAtA[iNdEx]
7399 iNdEx++
7400 v |= int64(b&0x7F) << shift
7401 if b < 0x80 {
7402 break
7403 }
7404 }
7405 m.MinLength = &v
7406 case 15:
7407 if wireType != 2 {
7408 return fmt.Errorf("proto: wrong wireType = %d for field Pattern", wireType)
7409 }
7410 var stringLen uint64
7411 for shift := uint(0); ; shift += 7 {
7412 if shift >= 64 {
7413 return ErrIntOverflowGenerated
7414 }
7415 if iNdEx >= l {
7416 return io.ErrUnexpectedEOF
7417 }
7418 b := dAtA[iNdEx]
7419 iNdEx++
7420 stringLen |= uint64(b&0x7F) << shift
7421 if b < 0x80 {
7422 break
7423 }
7424 }
7425 intStringLen := int(stringLen)
7426 if intStringLen < 0 {
7427 return ErrInvalidLengthGenerated
7428 }
7429 postIndex := iNdEx + intStringLen
7430 if postIndex < 0 {
7431 return ErrInvalidLengthGenerated
7432 }
7433 if postIndex > l {
7434 return io.ErrUnexpectedEOF
7435 }
7436 m.Pattern = string(dAtA[iNdEx:postIndex])
7437 iNdEx = postIndex
7438 case 16:
7439 if wireType != 0 {
7440 return fmt.Errorf("proto: wrong wireType = %d for field MaxItems", wireType)
7441 }
7442 var v int64
7443 for shift := uint(0); ; shift += 7 {
7444 if shift >= 64 {
7445 return ErrIntOverflowGenerated
7446 }
7447 if iNdEx >= l {
7448 return io.ErrUnexpectedEOF
7449 }
7450 b := dAtA[iNdEx]
7451 iNdEx++
7452 v |= int64(b&0x7F) << shift
7453 if b < 0x80 {
7454 break
7455 }
7456 }
7457 m.MaxItems = &v
7458 case 17:
7459 if wireType != 0 {
7460 return fmt.Errorf("proto: wrong wireType = %d for field MinItems", wireType)
7461 }
7462 var v int64
7463 for shift := uint(0); ; shift += 7 {
7464 if shift >= 64 {
7465 return ErrIntOverflowGenerated
7466 }
7467 if iNdEx >= l {
7468 return io.ErrUnexpectedEOF
7469 }
7470 b := dAtA[iNdEx]
7471 iNdEx++
7472 v |= int64(b&0x7F) << shift
7473 if b < 0x80 {
7474 break
7475 }
7476 }
7477 m.MinItems = &v
7478 case 18:
7479 if wireType != 0 {
7480 return fmt.Errorf("proto: wrong wireType = %d for field UniqueItems", wireType)
7481 }
7482 var v int
7483 for shift := uint(0); ; shift += 7 {
7484 if shift >= 64 {
7485 return ErrIntOverflowGenerated
7486 }
7487 if iNdEx >= l {
7488 return io.ErrUnexpectedEOF
7489 }
7490 b := dAtA[iNdEx]
7491 iNdEx++
7492 v |= int(b&0x7F) << shift
7493 if b < 0x80 {
7494 break
7495 }
7496 }
7497 m.UniqueItems = bool(v != 0)
7498 case 19:
7499 if wireType != 1 {
7500 return fmt.Errorf("proto: wrong wireType = %d for field MultipleOf", wireType)
7501 }
7502 var v uint64
7503 if (iNdEx + 8) > l {
7504 return io.ErrUnexpectedEOF
7505 }
7506 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7507 iNdEx += 8
7508 v2 := float64(math.Float64frombits(v))
7509 m.MultipleOf = &v2
7510 case 20:
7511 if wireType != 2 {
7512 return fmt.Errorf("proto: wrong wireType = %d for field Enum", wireType)
7513 }
7514 var msglen int
7515 for shift := uint(0); ; shift += 7 {
7516 if shift >= 64 {
7517 return ErrIntOverflowGenerated
7518 }
7519 if iNdEx >= l {
7520 return io.ErrUnexpectedEOF
7521 }
7522 b := dAtA[iNdEx]
7523 iNdEx++
7524 msglen |= int(b&0x7F) << shift
7525 if b < 0x80 {
7526 break
7527 }
7528 }
7529 if msglen < 0 {
7530 return ErrInvalidLengthGenerated
7531 }
7532 postIndex := iNdEx + msglen
7533 if postIndex < 0 {
7534 return ErrInvalidLengthGenerated
7535 }
7536 if postIndex > l {
7537 return io.ErrUnexpectedEOF
7538 }
7539 m.Enum = append(m.Enum, JSON{})
7540 if err := m.Enum[len(m.Enum)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7541 return err
7542 }
7543 iNdEx = postIndex
7544 case 21:
7545 if wireType != 0 {
7546 return fmt.Errorf("proto: wrong wireType = %d for field MaxProperties", wireType)
7547 }
7548 var v int64
7549 for shift := uint(0); ; shift += 7 {
7550 if shift >= 64 {
7551 return ErrIntOverflowGenerated
7552 }
7553 if iNdEx >= l {
7554 return io.ErrUnexpectedEOF
7555 }
7556 b := dAtA[iNdEx]
7557 iNdEx++
7558 v |= int64(b&0x7F) << shift
7559 if b < 0x80 {
7560 break
7561 }
7562 }
7563 m.MaxProperties = &v
7564 case 22:
7565 if wireType != 0 {
7566 return fmt.Errorf("proto: wrong wireType = %d for field MinProperties", wireType)
7567 }
7568 var v int64
7569 for shift := uint(0); ; shift += 7 {
7570 if shift >= 64 {
7571 return ErrIntOverflowGenerated
7572 }
7573 if iNdEx >= l {
7574 return io.ErrUnexpectedEOF
7575 }
7576 b := dAtA[iNdEx]
7577 iNdEx++
7578 v |= int64(b&0x7F) << shift
7579 if b < 0x80 {
7580 break
7581 }
7582 }
7583 m.MinProperties = &v
7584 case 23:
7585 if wireType != 2 {
7586 return fmt.Errorf("proto: wrong wireType = %d for field Required", wireType)
7587 }
7588 var stringLen uint64
7589 for shift := uint(0); ; shift += 7 {
7590 if shift >= 64 {
7591 return ErrIntOverflowGenerated
7592 }
7593 if iNdEx >= l {
7594 return io.ErrUnexpectedEOF
7595 }
7596 b := dAtA[iNdEx]
7597 iNdEx++
7598 stringLen |= uint64(b&0x7F) << shift
7599 if b < 0x80 {
7600 break
7601 }
7602 }
7603 intStringLen := int(stringLen)
7604 if intStringLen < 0 {
7605 return ErrInvalidLengthGenerated
7606 }
7607 postIndex := iNdEx + intStringLen
7608 if postIndex < 0 {
7609 return ErrInvalidLengthGenerated
7610 }
7611 if postIndex > l {
7612 return io.ErrUnexpectedEOF
7613 }
7614 m.Required = append(m.Required, string(dAtA[iNdEx:postIndex]))
7615 iNdEx = postIndex
7616 case 24:
7617 if wireType != 2 {
7618 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7619 }
7620 var msglen int
7621 for shift := uint(0); ; shift += 7 {
7622 if shift >= 64 {
7623 return ErrIntOverflowGenerated
7624 }
7625 if iNdEx >= l {
7626 return io.ErrUnexpectedEOF
7627 }
7628 b := dAtA[iNdEx]
7629 iNdEx++
7630 msglen |= int(b&0x7F) << shift
7631 if b < 0x80 {
7632 break
7633 }
7634 }
7635 if msglen < 0 {
7636 return ErrInvalidLengthGenerated
7637 }
7638 postIndex := iNdEx + msglen
7639 if postIndex < 0 {
7640 return ErrInvalidLengthGenerated
7641 }
7642 if postIndex > l {
7643 return io.ErrUnexpectedEOF
7644 }
7645 if m.Items == nil {
7646 m.Items = &JSONSchemaPropsOrArray{}
7647 }
7648 if err := m.Items.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7649 return err
7650 }
7651 iNdEx = postIndex
7652 case 25:
7653 if wireType != 2 {
7654 return fmt.Errorf("proto: wrong wireType = %d for field AllOf", wireType)
7655 }
7656 var msglen int
7657 for shift := uint(0); ; shift += 7 {
7658 if shift >= 64 {
7659 return ErrIntOverflowGenerated
7660 }
7661 if iNdEx >= l {
7662 return io.ErrUnexpectedEOF
7663 }
7664 b := dAtA[iNdEx]
7665 iNdEx++
7666 msglen |= int(b&0x7F) << shift
7667 if b < 0x80 {
7668 break
7669 }
7670 }
7671 if msglen < 0 {
7672 return ErrInvalidLengthGenerated
7673 }
7674 postIndex := iNdEx + msglen
7675 if postIndex < 0 {
7676 return ErrInvalidLengthGenerated
7677 }
7678 if postIndex > l {
7679 return io.ErrUnexpectedEOF
7680 }
7681 m.AllOf = append(m.AllOf, JSONSchemaProps{})
7682 if err := m.AllOf[len(m.AllOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7683 return err
7684 }
7685 iNdEx = postIndex
7686 case 26:
7687 if wireType != 2 {
7688 return fmt.Errorf("proto: wrong wireType = %d for field OneOf", wireType)
7689 }
7690 var msglen int
7691 for shift := uint(0); ; shift += 7 {
7692 if shift >= 64 {
7693 return ErrIntOverflowGenerated
7694 }
7695 if iNdEx >= l {
7696 return io.ErrUnexpectedEOF
7697 }
7698 b := dAtA[iNdEx]
7699 iNdEx++
7700 msglen |= int(b&0x7F) << shift
7701 if b < 0x80 {
7702 break
7703 }
7704 }
7705 if msglen < 0 {
7706 return ErrInvalidLengthGenerated
7707 }
7708 postIndex := iNdEx + msglen
7709 if postIndex < 0 {
7710 return ErrInvalidLengthGenerated
7711 }
7712 if postIndex > l {
7713 return io.ErrUnexpectedEOF
7714 }
7715 m.OneOf = append(m.OneOf, JSONSchemaProps{})
7716 if err := m.OneOf[len(m.OneOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7717 return err
7718 }
7719 iNdEx = postIndex
7720 case 27:
7721 if wireType != 2 {
7722 return fmt.Errorf("proto: wrong wireType = %d for field AnyOf", wireType)
7723 }
7724 var msglen int
7725 for shift := uint(0); ; shift += 7 {
7726 if shift >= 64 {
7727 return ErrIntOverflowGenerated
7728 }
7729 if iNdEx >= l {
7730 return io.ErrUnexpectedEOF
7731 }
7732 b := dAtA[iNdEx]
7733 iNdEx++
7734 msglen |= int(b&0x7F) << shift
7735 if b < 0x80 {
7736 break
7737 }
7738 }
7739 if msglen < 0 {
7740 return ErrInvalidLengthGenerated
7741 }
7742 postIndex := iNdEx + msglen
7743 if postIndex < 0 {
7744 return ErrInvalidLengthGenerated
7745 }
7746 if postIndex > l {
7747 return io.ErrUnexpectedEOF
7748 }
7749 m.AnyOf = append(m.AnyOf, JSONSchemaProps{})
7750 if err := m.AnyOf[len(m.AnyOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7751 return err
7752 }
7753 iNdEx = postIndex
7754 case 28:
7755 if wireType != 2 {
7756 return fmt.Errorf("proto: wrong wireType = %d for field Not", wireType)
7757 }
7758 var msglen int
7759 for shift := uint(0); ; shift += 7 {
7760 if shift >= 64 {
7761 return ErrIntOverflowGenerated
7762 }
7763 if iNdEx >= l {
7764 return io.ErrUnexpectedEOF
7765 }
7766 b := dAtA[iNdEx]
7767 iNdEx++
7768 msglen |= int(b&0x7F) << shift
7769 if b < 0x80 {
7770 break
7771 }
7772 }
7773 if msglen < 0 {
7774 return ErrInvalidLengthGenerated
7775 }
7776 postIndex := iNdEx + msglen
7777 if postIndex < 0 {
7778 return ErrInvalidLengthGenerated
7779 }
7780 if postIndex > l {
7781 return io.ErrUnexpectedEOF
7782 }
7783 if m.Not == nil {
7784 m.Not = &JSONSchemaProps{}
7785 }
7786 if err := m.Not.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7787 return err
7788 }
7789 iNdEx = postIndex
7790 case 29:
7791 if wireType != 2 {
7792 return fmt.Errorf("proto: wrong wireType = %d for field Properties", wireType)
7793 }
7794 var msglen int
7795 for shift := uint(0); ; shift += 7 {
7796 if shift >= 64 {
7797 return ErrIntOverflowGenerated
7798 }
7799 if iNdEx >= l {
7800 return io.ErrUnexpectedEOF
7801 }
7802 b := dAtA[iNdEx]
7803 iNdEx++
7804 msglen |= int(b&0x7F) << shift
7805 if b < 0x80 {
7806 break
7807 }
7808 }
7809 if msglen < 0 {
7810 return ErrInvalidLengthGenerated
7811 }
7812 postIndex := iNdEx + msglen
7813 if postIndex < 0 {
7814 return ErrInvalidLengthGenerated
7815 }
7816 if postIndex > l {
7817 return io.ErrUnexpectedEOF
7818 }
7819 if m.Properties == nil {
7820 m.Properties = make(map[string]JSONSchemaProps)
7821 }
7822 var mapkey string
7823 mapvalue := &JSONSchemaProps{}
7824 for iNdEx < postIndex {
7825 entryPreIndex := iNdEx
7826 var wire uint64
7827 for shift := uint(0); ; shift += 7 {
7828 if shift >= 64 {
7829 return ErrIntOverflowGenerated
7830 }
7831 if iNdEx >= l {
7832 return io.ErrUnexpectedEOF
7833 }
7834 b := dAtA[iNdEx]
7835 iNdEx++
7836 wire |= uint64(b&0x7F) << shift
7837 if b < 0x80 {
7838 break
7839 }
7840 }
7841 fieldNum := int32(wire >> 3)
7842 if fieldNum == 1 {
7843 var stringLenmapkey uint64
7844 for shift := uint(0); ; shift += 7 {
7845 if shift >= 64 {
7846 return ErrIntOverflowGenerated
7847 }
7848 if iNdEx >= l {
7849 return io.ErrUnexpectedEOF
7850 }
7851 b := dAtA[iNdEx]
7852 iNdEx++
7853 stringLenmapkey |= uint64(b&0x7F) << shift
7854 if b < 0x80 {
7855 break
7856 }
7857 }
7858 intStringLenmapkey := int(stringLenmapkey)
7859 if intStringLenmapkey < 0 {
7860 return ErrInvalidLengthGenerated
7861 }
7862 postStringIndexmapkey := iNdEx + intStringLenmapkey
7863 if postStringIndexmapkey < 0 {
7864 return ErrInvalidLengthGenerated
7865 }
7866 if postStringIndexmapkey > l {
7867 return io.ErrUnexpectedEOF
7868 }
7869 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7870 iNdEx = postStringIndexmapkey
7871 } else if fieldNum == 2 {
7872 var mapmsglen int
7873 for shift := uint(0); ; shift += 7 {
7874 if shift >= 64 {
7875 return ErrIntOverflowGenerated
7876 }
7877 if iNdEx >= l {
7878 return io.ErrUnexpectedEOF
7879 }
7880 b := dAtA[iNdEx]
7881 iNdEx++
7882 mapmsglen |= int(b&0x7F) << shift
7883 if b < 0x80 {
7884 break
7885 }
7886 }
7887 if mapmsglen < 0 {
7888 return ErrInvalidLengthGenerated
7889 }
7890 postmsgIndex := iNdEx + mapmsglen
7891 if postmsgIndex < 0 {
7892 return ErrInvalidLengthGenerated
7893 }
7894 if postmsgIndex > l {
7895 return io.ErrUnexpectedEOF
7896 }
7897 mapvalue = &JSONSchemaProps{}
7898 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
7899 return err
7900 }
7901 iNdEx = postmsgIndex
7902 } else {
7903 iNdEx = entryPreIndex
7904 skippy, err := skipGenerated(dAtA[iNdEx:])
7905 if err != nil {
7906 return err
7907 }
7908 if (skippy < 0) || (iNdEx+skippy) < 0 {
7909 return ErrInvalidLengthGenerated
7910 }
7911 if (iNdEx + skippy) > postIndex {
7912 return io.ErrUnexpectedEOF
7913 }
7914 iNdEx += skippy
7915 }
7916 }
7917 m.Properties[mapkey] = *mapvalue
7918 iNdEx = postIndex
7919 case 30:
7920 if wireType != 2 {
7921 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalProperties", wireType)
7922 }
7923 var msglen int
7924 for shift := uint(0); ; shift += 7 {
7925 if shift >= 64 {
7926 return ErrIntOverflowGenerated
7927 }
7928 if iNdEx >= l {
7929 return io.ErrUnexpectedEOF
7930 }
7931 b := dAtA[iNdEx]
7932 iNdEx++
7933 msglen |= int(b&0x7F) << shift
7934 if b < 0x80 {
7935 break
7936 }
7937 }
7938 if msglen < 0 {
7939 return ErrInvalidLengthGenerated
7940 }
7941 postIndex := iNdEx + msglen
7942 if postIndex < 0 {
7943 return ErrInvalidLengthGenerated
7944 }
7945 if postIndex > l {
7946 return io.ErrUnexpectedEOF
7947 }
7948 if m.AdditionalProperties == nil {
7949 m.AdditionalProperties = &JSONSchemaPropsOrBool{}
7950 }
7951 if err := m.AdditionalProperties.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7952 return err
7953 }
7954 iNdEx = postIndex
7955 case 31:
7956 if wireType != 2 {
7957 return fmt.Errorf("proto: wrong wireType = %d for field PatternProperties", wireType)
7958 }
7959 var msglen int
7960 for shift := uint(0); ; shift += 7 {
7961 if shift >= 64 {
7962 return ErrIntOverflowGenerated
7963 }
7964 if iNdEx >= l {
7965 return io.ErrUnexpectedEOF
7966 }
7967 b := dAtA[iNdEx]
7968 iNdEx++
7969 msglen |= int(b&0x7F) << shift
7970 if b < 0x80 {
7971 break
7972 }
7973 }
7974 if msglen < 0 {
7975 return ErrInvalidLengthGenerated
7976 }
7977 postIndex := iNdEx + msglen
7978 if postIndex < 0 {
7979 return ErrInvalidLengthGenerated
7980 }
7981 if postIndex > l {
7982 return io.ErrUnexpectedEOF
7983 }
7984 if m.PatternProperties == nil {
7985 m.PatternProperties = make(map[string]JSONSchemaProps)
7986 }
7987 var mapkey string
7988 mapvalue := &JSONSchemaProps{}
7989 for iNdEx < postIndex {
7990 entryPreIndex := iNdEx
7991 var wire uint64
7992 for shift := uint(0); ; shift += 7 {
7993 if shift >= 64 {
7994 return ErrIntOverflowGenerated
7995 }
7996 if iNdEx >= l {
7997 return io.ErrUnexpectedEOF
7998 }
7999 b := dAtA[iNdEx]
8000 iNdEx++
8001 wire |= uint64(b&0x7F) << shift
8002 if b < 0x80 {
8003 break
8004 }
8005 }
8006 fieldNum := int32(wire >> 3)
8007 if fieldNum == 1 {
8008 var stringLenmapkey uint64
8009 for shift := uint(0); ; shift += 7 {
8010 if shift >= 64 {
8011 return ErrIntOverflowGenerated
8012 }
8013 if iNdEx >= l {
8014 return io.ErrUnexpectedEOF
8015 }
8016 b := dAtA[iNdEx]
8017 iNdEx++
8018 stringLenmapkey |= uint64(b&0x7F) << shift
8019 if b < 0x80 {
8020 break
8021 }
8022 }
8023 intStringLenmapkey := int(stringLenmapkey)
8024 if intStringLenmapkey < 0 {
8025 return ErrInvalidLengthGenerated
8026 }
8027 postStringIndexmapkey := iNdEx + intStringLenmapkey
8028 if postStringIndexmapkey < 0 {
8029 return ErrInvalidLengthGenerated
8030 }
8031 if postStringIndexmapkey > l {
8032 return io.ErrUnexpectedEOF
8033 }
8034 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8035 iNdEx = postStringIndexmapkey
8036 } else if fieldNum == 2 {
8037 var mapmsglen int
8038 for shift := uint(0); ; shift += 7 {
8039 if shift >= 64 {
8040 return ErrIntOverflowGenerated
8041 }
8042 if iNdEx >= l {
8043 return io.ErrUnexpectedEOF
8044 }
8045 b := dAtA[iNdEx]
8046 iNdEx++
8047 mapmsglen |= int(b&0x7F) << shift
8048 if b < 0x80 {
8049 break
8050 }
8051 }
8052 if mapmsglen < 0 {
8053 return ErrInvalidLengthGenerated
8054 }
8055 postmsgIndex := iNdEx + mapmsglen
8056 if postmsgIndex < 0 {
8057 return ErrInvalidLengthGenerated
8058 }
8059 if postmsgIndex > l {
8060 return io.ErrUnexpectedEOF
8061 }
8062 mapvalue = &JSONSchemaProps{}
8063 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
8064 return err
8065 }
8066 iNdEx = postmsgIndex
8067 } else {
8068 iNdEx = entryPreIndex
8069 skippy, err := skipGenerated(dAtA[iNdEx:])
8070 if err != nil {
8071 return err
8072 }
8073 if (skippy < 0) || (iNdEx+skippy) < 0 {
8074 return ErrInvalidLengthGenerated
8075 }
8076 if (iNdEx + skippy) > postIndex {
8077 return io.ErrUnexpectedEOF
8078 }
8079 iNdEx += skippy
8080 }
8081 }
8082 m.PatternProperties[mapkey] = *mapvalue
8083 iNdEx = postIndex
8084 case 32:
8085 if wireType != 2 {
8086 return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
8087 }
8088 var msglen int
8089 for shift := uint(0); ; shift += 7 {
8090 if shift >= 64 {
8091 return ErrIntOverflowGenerated
8092 }
8093 if iNdEx >= l {
8094 return io.ErrUnexpectedEOF
8095 }
8096 b := dAtA[iNdEx]
8097 iNdEx++
8098 msglen |= int(b&0x7F) << shift
8099 if b < 0x80 {
8100 break
8101 }
8102 }
8103 if msglen < 0 {
8104 return ErrInvalidLengthGenerated
8105 }
8106 postIndex := iNdEx + msglen
8107 if postIndex < 0 {
8108 return ErrInvalidLengthGenerated
8109 }
8110 if postIndex > l {
8111 return io.ErrUnexpectedEOF
8112 }
8113 if m.Dependencies == nil {
8114 m.Dependencies = make(JSONSchemaDependencies)
8115 }
8116 var mapkey string
8117 mapvalue := &JSONSchemaPropsOrStringArray{}
8118 for iNdEx < postIndex {
8119 entryPreIndex := iNdEx
8120 var wire uint64
8121 for shift := uint(0); ; shift += 7 {
8122 if shift >= 64 {
8123 return ErrIntOverflowGenerated
8124 }
8125 if iNdEx >= l {
8126 return io.ErrUnexpectedEOF
8127 }
8128 b := dAtA[iNdEx]
8129 iNdEx++
8130 wire |= uint64(b&0x7F) << shift
8131 if b < 0x80 {
8132 break
8133 }
8134 }
8135 fieldNum := int32(wire >> 3)
8136 if fieldNum == 1 {
8137 var stringLenmapkey uint64
8138 for shift := uint(0); ; shift += 7 {
8139 if shift >= 64 {
8140 return ErrIntOverflowGenerated
8141 }
8142 if iNdEx >= l {
8143 return io.ErrUnexpectedEOF
8144 }
8145 b := dAtA[iNdEx]
8146 iNdEx++
8147 stringLenmapkey |= uint64(b&0x7F) << shift
8148 if b < 0x80 {
8149 break
8150 }
8151 }
8152 intStringLenmapkey := int(stringLenmapkey)
8153 if intStringLenmapkey < 0 {
8154 return ErrInvalidLengthGenerated
8155 }
8156 postStringIndexmapkey := iNdEx + intStringLenmapkey
8157 if postStringIndexmapkey < 0 {
8158 return ErrInvalidLengthGenerated
8159 }
8160 if postStringIndexmapkey > l {
8161 return io.ErrUnexpectedEOF
8162 }
8163 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8164 iNdEx = postStringIndexmapkey
8165 } else if fieldNum == 2 {
8166 var mapmsglen int
8167 for shift := uint(0); ; shift += 7 {
8168 if shift >= 64 {
8169 return ErrIntOverflowGenerated
8170 }
8171 if iNdEx >= l {
8172 return io.ErrUnexpectedEOF
8173 }
8174 b := dAtA[iNdEx]
8175 iNdEx++
8176 mapmsglen |= int(b&0x7F) << shift
8177 if b < 0x80 {
8178 break
8179 }
8180 }
8181 if mapmsglen < 0 {
8182 return ErrInvalidLengthGenerated
8183 }
8184 postmsgIndex := iNdEx + mapmsglen
8185 if postmsgIndex < 0 {
8186 return ErrInvalidLengthGenerated
8187 }
8188 if postmsgIndex > l {
8189 return io.ErrUnexpectedEOF
8190 }
8191 mapvalue = &JSONSchemaPropsOrStringArray{}
8192 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
8193 return err
8194 }
8195 iNdEx = postmsgIndex
8196 } else {
8197 iNdEx = entryPreIndex
8198 skippy, err := skipGenerated(dAtA[iNdEx:])
8199 if err != nil {
8200 return err
8201 }
8202 if (skippy < 0) || (iNdEx+skippy) < 0 {
8203 return ErrInvalidLengthGenerated
8204 }
8205 if (iNdEx + skippy) > postIndex {
8206 return io.ErrUnexpectedEOF
8207 }
8208 iNdEx += skippy
8209 }
8210 }
8211 m.Dependencies[mapkey] = *mapvalue
8212 iNdEx = postIndex
8213 case 33:
8214 if wireType != 2 {
8215 return fmt.Errorf("proto: wrong wireType = %d for field AdditionalItems", wireType)
8216 }
8217 var msglen int
8218 for shift := uint(0); ; shift += 7 {
8219 if shift >= 64 {
8220 return ErrIntOverflowGenerated
8221 }
8222 if iNdEx >= l {
8223 return io.ErrUnexpectedEOF
8224 }
8225 b := dAtA[iNdEx]
8226 iNdEx++
8227 msglen |= int(b&0x7F) << shift
8228 if b < 0x80 {
8229 break
8230 }
8231 }
8232 if msglen < 0 {
8233 return ErrInvalidLengthGenerated
8234 }
8235 postIndex := iNdEx + msglen
8236 if postIndex < 0 {
8237 return ErrInvalidLengthGenerated
8238 }
8239 if postIndex > l {
8240 return io.ErrUnexpectedEOF
8241 }
8242 if m.AdditionalItems == nil {
8243 m.AdditionalItems = &JSONSchemaPropsOrBool{}
8244 }
8245 if err := m.AdditionalItems.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8246 return err
8247 }
8248 iNdEx = postIndex
8249 case 34:
8250 if wireType != 2 {
8251 return fmt.Errorf("proto: wrong wireType = %d for field Definitions", wireType)
8252 }
8253 var msglen int
8254 for shift := uint(0); ; shift += 7 {
8255 if shift >= 64 {
8256 return ErrIntOverflowGenerated
8257 }
8258 if iNdEx >= l {
8259 return io.ErrUnexpectedEOF
8260 }
8261 b := dAtA[iNdEx]
8262 iNdEx++
8263 msglen |= int(b&0x7F) << shift
8264 if b < 0x80 {
8265 break
8266 }
8267 }
8268 if msglen < 0 {
8269 return ErrInvalidLengthGenerated
8270 }
8271 postIndex := iNdEx + msglen
8272 if postIndex < 0 {
8273 return ErrInvalidLengthGenerated
8274 }
8275 if postIndex > l {
8276 return io.ErrUnexpectedEOF
8277 }
8278 if m.Definitions == nil {
8279 m.Definitions = make(JSONSchemaDefinitions)
8280 }
8281 var mapkey string
8282 mapvalue := &JSONSchemaProps{}
8283 for iNdEx < postIndex {
8284 entryPreIndex := iNdEx
8285 var wire uint64
8286 for shift := uint(0); ; shift += 7 {
8287 if shift >= 64 {
8288 return ErrIntOverflowGenerated
8289 }
8290 if iNdEx >= l {
8291 return io.ErrUnexpectedEOF
8292 }
8293 b := dAtA[iNdEx]
8294 iNdEx++
8295 wire |= uint64(b&0x7F) << shift
8296 if b < 0x80 {
8297 break
8298 }
8299 }
8300 fieldNum := int32(wire >> 3)
8301 if fieldNum == 1 {
8302 var stringLenmapkey uint64
8303 for shift := uint(0); ; shift += 7 {
8304 if shift >= 64 {
8305 return ErrIntOverflowGenerated
8306 }
8307 if iNdEx >= l {
8308 return io.ErrUnexpectedEOF
8309 }
8310 b := dAtA[iNdEx]
8311 iNdEx++
8312 stringLenmapkey |= uint64(b&0x7F) << shift
8313 if b < 0x80 {
8314 break
8315 }
8316 }
8317 intStringLenmapkey := int(stringLenmapkey)
8318 if intStringLenmapkey < 0 {
8319 return ErrInvalidLengthGenerated
8320 }
8321 postStringIndexmapkey := iNdEx + intStringLenmapkey
8322 if postStringIndexmapkey < 0 {
8323 return ErrInvalidLengthGenerated
8324 }
8325 if postStringIndexmapkey > l {
8326 return io.ErrUnexpectedEOF
8327 }
8328 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8329 iNdEx = postStringIndexmapkey
8330 } else if fieldNum == 2 {
8331 var mapmsglen int
8332 for shift := uint(0); ; shift += 7 {
8333 if shift >= 64 {
8334 return ErrIntOverflowGenerated
8335 }
8336 if iNdEx >= l {
8337 return io.ErrUnexpectedEOF
8338 }
8339 b := dAtA[iNdEx]
8340 iNdEx++
8341 mapmsglen |= int(b&0x7F) << shift
8342 if b < 0x80 {
8343 break
8344 }
8345 }
8346 if mapmsglen < 0 {
8347 return ErrInvalidLengthGenerated
8348 }
8349 postmsgIndex := iNdEx + mapmsglen
8350 if postmsgIndex < 0 {
8351 return ErrInvalidLengthGenerated
8352 }
8353 if postmsgIndex > l {
8354 return io.ErrUnexpectedEOF
8355 }
8356 mapvalue = &JSONSchemaProps{}
8357 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
8358 return err
8359 }
8360 iNdEx = postmsgIndex
8361 } else {
8362 iNdEx = entryPreIndex
8363 skippy, err := skipGenerated(dAtA[iNdEx:])
8364 if err != nil {
8365 return err
8366 }
8367 if (skippy < 0) || (iNdEx+skippy) < 0 {
8368 return ErrInvalidLengthGenerated
8369 }
8370 if (iNdEx + skippy) > postIndex {
8371 return io.ErrUnexpectedEOF
8372 }
8373 iNdEx += skippy
8374 }
8375 }
8376 m.Definitions[mapkey] = *mapvalue
8377 iNdEx = postIndex
8378 case 35:
8379 if wireType != 2 {
8380 return fmt.Errorf("proto: wrong wireType = %d for field ExternalDocs", wireType)
8381 }
8382 var msglen int
8383 for shift := uint(0); ; shift += 7 {
8384 if shift >= 64 {
8385 return ErrIntOverflowGenerated
8386 }
8387 if iNdEx >= l {
8388 return io.ErrUnexpectedEOF
8389 }
8390 b := dAtA[iNdEx]
8391 iNdEx++
8392 msglen |= int(b&0x7F) << shift
8393 if b < 0x80 {
8394 break
8395 }
8396 }
8397 if msglen < 0 {
8398 return ErrInvalidLengthGenerated
8399 }
8400 postIndex := iNdEx + msglen
8401 if postIndex < 0 {
8402 return ErrInvalidLengthGenerated
8403 }
8404 if postIndex > l {
8405 return io.ErrUnexpectedEOF
8406 }
8407 if m.ExternalDocs == nil {
8408 m.ExternalDocs = &ExternalDocumentation{}
8409 }
8410 if err := m.ExternalDocs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8411 return err
8412 }
8413 iNdEx = postIndex
8414 case 36:
8415 if wireType != 2 {
8416 return fmt.Errorf("proto: wrong wireType = %d for field Example", wireType)
8417 }
8418 var msglen int
8419 for shift := uint(0); ; shift += 7 {
8420 if shift >= 64 {
8421 return ErrIntOverflowGenerated
8422 }
8423 if iNdEx >= l {
8424 return io.ErrUnexpectedEOF
8425 }
8426 b := dAtA[iNdEx]
8427 iNdEx++
8428 msglen |= int(b&0x7F) << shift
8429 if b < 0x80 {
8430 break
8431 }
8432 }
8433 if msglen < 0 {
8434 return ErrInvalidLengthGenerated
8435 }
8436 postIndex := iNdEx + msglen
8437 if postIndex < 0 {
8438 return ErrInvalidLengthGenerated
8439 }
8440 if postIndex > l {
8441 return io.ErrUnexpectedEOF
8442 }
8443 if m.Example == nil {
8444 m.Example = &JSON{}
8445 }
8446 if err := m.Example.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8447 return err
8448 }
8449 iNdEx = postIndex
8450 case 37:
8451 if wireType != 0 {
8452 return fmt.Errorf("proto: wrong wireType = %d for field Nullable", wireType)
8453 }
8454 var v int
8455 for shift := uint(0); ; shift += 7 {
8456 if shift >= 64 {
8457 return ErrIntOverflowGenerated
8458 }
8459 if iNdEx >= l {
8460 return io.ErrUnexpectedEOF
8461 }
8462 b := dAtA[iNdEx]
8463 iNdEx++
8464 v |= int(b&0x7F) << shift
8465 if b < 0x80 {
8466 break
8467 }
8468 }
8469 m.Nullable = bool(v != 0)
8470 case 38:
8471 if wireType != 0 {
8472 return fmt.Errorf("proto: wrong wireType = %d for field XPreserveUnknownFields", wireType)
8473 }
8474 var v int
8475 for shift := uint(0); ; shift += 7 {
8476 if shift >= 64 {
8477 return ErrIntOverflowGenerated
8478 }
8479 if iNdEx >= l {
8480 return io.ErrUnexpectedEOF
8481 }
8482 b := dAtA[iNdEx]
8483 iNdEx++
8484 v |= int(b&0x7F) << shift
8485 if b < 0x80 {
8486 break
8487 }
8488 }
8489 b := bool(v != 0)
8490 m.XPreserveUnknownFields = &b
8491 case 39:
8492 if wireType != 0 {
8493 return fmt.Errorf("proto: wrong wireType = %d for field XEmbeddedResource", wireType)
8494 }
8495 var v int
8496 for shift := uint(0); ; shift += 7 {
8497 if shift >= 64 {
8498 return ErrIntOverflowGenerated
8499 }
8500 if iNdEx >= l {
8501 return io.ErrUnexpectedEOF
8502 }
8503 b := dAtA[iNdEx]
8504 iNdEx++
8505 v |= int(b&0x7F) << shift
8506 if b < 0x80 {
8507 break
8508 }
8509 }
8510 m.XEmbeddedResource = bool(v != 0)
8511 case 40:
8512 if wireType != 0 {
8513 return fmt.Errorf("proto: wrong wireType = %d for field XIntOrString", wireType)
8514 }
8515 var v int
8516 for shift := uint(0); ; shift += 7 {
8517 if shift >= 64 {
8518 return ErrIntOverflowGenerated
8519 }
8520 if iNdEx >= l {
8521 return io.ErrUnexpectedEOF
8522 }
8523 b := dAtA[iNdEx]
8524 iNdEx++
8525 v |= int(b&0x7F) << shift
8526 if b < 0x80 {
8527 break
8528 }
8529 }
8530 m.XIntOrString = bool(v != 0)
8531 case 41:
8532 if wireType != 2 {
8533 return fmt.Errorf("proto: wrong wireType = %d for field XListMapKeys", wireType)
8534 }
8535 var stringLen uint64
8536 for shift := uint(0); ; shift += 7 {
8537 if shift >= 64 {
8538 return ErrIntOverflowGenerated
8539 }
8540 if iNdEx >= l {
8541 return io.ErrUnexpectedEOF
8542 }
8543 b := dAtA[iNdEx]
8544 iNdEx++
8545 stringLen |= uint64(b&0x7F) << shift
8546 if b < 0x80 {
8547 break
8548 }
8549 }
8550 intStringLen := int(stringLen)
8551 if intStringLen < 0 {
8552 return ErrInvalidLengthGenerated
8553 }
8554 postIndex := iNdEx + intStringLen
8555 if postIndex < 0 {
8556 return ErrInvalidLengthGenerated
8557 }
8558 if postIndex > l {
8559 return io.ErrUnexpectedEOF
8560 }
8561 m.XListMapKeys = append(m.XListMapKeys, string(dAtA[iNdEx:postIndex]))
8562 iNdEx = postIndex
8563 case 42:
8564 if wireType != 2 {
8565 return fmt.Errorf("proto: wrong wireType = %d for field XListType", wireType)
8566 }
8567 var stringLen uint64
8568 for shift := uint(0); ; shift += 7 {
8569 if shift >= 64 {
8570 return ErrIntOverflowGenerated
8571 }
8572 if iNdEx >= l {
8573 return io.ErrUnexpectedEOF
8574 }
8575 b := dAtA[iNdEx]
8576 iNdEx++
8577 stringLen |= uint64(b&0x7F) << shift
8578 if b < 0x80 {
8579 break
8580 }
8581 }
8582 intStringLen := int(stringLen)
8583 if intStringLen < 0 {
8584 return ErrInvalidLengthGenerated
8585 }
8586 postIndex := iNdEx + intStringLen
8587 if postIndex < 0 {
8588 return ErrInvalidLengthGenerated
8589 }
8590 if postIndex > l {
8591 return io.ErrUnexpectedEOF
8592 }
8593 s := string(dAtA[iNdEx:postIndex])
8594 m.XListType = &s
8595 iNdEx = postIndex
8596 case 43:
8597 if wireType != 2 {
8598 return fmt.Errorf("proto: wrong wireType = %d for field XMapType", wireType)
8599 }
8600 var stringLen uint64
8601 for shift := uint(0); ; shift += 7 {
8602 if shift >= 64 {
8603 return ErrIntOverflowGenerated
8604 }
8605 if iNdEx >= l {
8606 return io.ErrUnexpectedEOF
8607 }
8608 b := dAtA[iNdEx]
8609 iNdEx++
8610 stringLen |= uint64(b&0x7F) << shift
8611 if b < 0x80 {
8612 break
8613 }
8614 }
8615 intStringLen := int(stringLen)
8616 if intStringLen < 0 {
8617 return ErrInvalidLengthGenerated
8618 }
8619 postIndex := iNdEx + intStringLen
8620 if postIndex < 0 {
8621 return ErrInvalidLengthGenerated
8622 }
8623 if postIndex > l {
8624 return io.ErrUnexpectedEOF
8625 }
8626 s := string(dAtA[iNdEx:postIndex])
8627 m.XMapType = &s
8628 iNdEx = postIndex
8629 case 44:
8630 if wireType != 2 {
8631 return fmt.Errorf("proto: wrong wireType = %d for field XValidations", wireType)
8632 }
8633 var msglen int
8634 for shift := uint(0); ; shift += 7 {
8635 if shift >= 64 {
8636 return ErrIntOverflowGenerated
8637 }
8638 if iNdEx >= l {
8639 return io.ErrUnexpectedEOF
8640 }
8641 b := dAtA[iNdEx]
8642 iNdEx++
8643 msglen |= int(b&0x7F) << shift
8644 if b < 0x80 {
8645 break
8646 }
8647 }
8648 if msglen < 0 {
8649 return ErrInvalidLengthGenerated
8650 }
8651 postIndex := iNdEx + msglen
8652 if postIndex < 0 {
8653 return ErrInvalidLengthGenerated
8654 }
8655 if postIndex > l {
8656 return io.ErrUnexpectedEOF
8657 }
8658 m.XValidations = append(m.XValidations, ValidationRule{})
8659 if err := m.XValidations[len(m.XValidations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8660 return err
8661 }
8662 iNdEx = postIndex
8663 default:
8664 iNdEx = preIndex
8665 skippy, err := skipGenerated(dAtA[iNdEx:])
8666 if err != nil {
8667 return err
8668 }
8669 if (skippy < 0) || (iNdEx+skippy) < 0 {
8670 return ErrInvalidLengthGenerated
8671 }
8672 if (iNdEx + skippy) > l {
8673 return io.ErrUnexpectedEOF
8674 }
8675 iNdEx += skippy
8676 }
8677 }
8678
8679 if iNdEx > l {
8680 return io.ErrUnexpectedEOF
8681 }
8682 return nil
8683 }
8684 func (m *JSONSchemaPropsOrArray) Unmarshal(dAtA []byte) error {
8685 l := len(dAtA)
8686 iNdEx := 0
8687 for iNdEx < l {
8688 preIndex := iNdEx
8689 var wire uint64
8690 for shift := uint(0); ; shift += 7 {
8691 if shift >= 64 {
8692 return ErrIntOverflowGenerated
8693 }
8694 if iNdEx >= l {
8695 return io.ErrUnexpectedEOF
8696 }
8697 b := dAtA[iNdEx]
8698 iNdEx++
8699 wire |= uint64(b&0x7F) << shift
8700 if b < 0x80 {
8701 break
8702 }
8703 }
8704 fieldNum := int32(wire >> 3)
8705 wireType := int(wire & 0x7)
8706 if wireType == 4 {
8707 return fmt.Errorf("proto: JSONSchemaPropsOrArray: wiretype end group for non-group")
8708 }
8709 if fieldNum <= 0 {
8710 return fmt.Errorf("proto: JSONSchemaPropsOrArray: illegal tag %d (wire type %d)", fieldNum, wire)
8711 }
8712 switch fieldNum {
8713 case 1:
8714 if wireType != 2 {
8715 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
8716 }
8717 var msglen int
8718 for shift := uint(0); ; shift += 7 {
8719 if shift >= 64 {
8720 return ErrIntOverflowGenerated
8721 }
8722 if iNdEx >= l {
8723 return io.ErrUnexpectedEOF
8724 }
8725 b := dAtA[iNdEx]
8726 iNdEx++
8727 msglen |= int(b&0x7F) << shift
8728 if b < 0x80 {
8729 break
8730 }
8731 }
8732 if msglen < 0 {
8733 return ErrInvalidLengthGenerated
8734 }
8735 postIndex := iNdEx + msglen
8736 if postIndex < 0 {
8737 return ErrInvalidLengthGenerated
8738 }
8739 if postIndex > l {
8740 return io.ErrUnexpectedEOF
8741 }
8742 if m.Schema == nil {
8743 m.Schema = &JSONSchemaProps{}
8744 }
8745 if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8746 return err
8747 }
8748 iNdEx = postIndex
8749 case 2:
8750 if wireType != 2 {
8751 return fmt.Errorf("proto: wrong wireType = %d for field JSONSchemas", wireType)
8752 }
8753 var msglen int
8754 for shift := uint(0); ; shift += 7 {
8755 if shift >= 64 {
8756 return ErrIntOverflowGenerated
8757 }
8758 if iNdEx >= l {
8759 return io.ErrUnexpectedEOF
8760 }
8761 b := dAtA[iNdEx]
8762 iNdEx++
8763 msglen |= int(b&0x7F) << shift
8764 if b < 0x80 {
8765 break
8766 }
8767 }
8768 if msglen < 0 {
8769 return ErrInvalidLengthGenerated
8770 }
8771 postIndex := iNdEx + msglen
8772 if postIndex < 0 {
8773 return ErrInvalidLengthGenerated
8774 }
8775 if postIndex > l {
8776 return io.ErrUnexpectedEOF
8777 }
8778 m.JSONSchemas = append(m.JSONSchemas, JSONSchemaProps{})
8779 if err := m.JSONSchemas[len(m.JSONSchemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8780 return err
8781 }
8782 iNdEx = postIndex
8783 default:
8784 iNdEx = preIndex
8785 skippy, err := skipGenerated(dAtA[iNdEx:])
8786 if err != nil {
8787 return err
8788 }
8789 if (skippy < 0) || (iNdEx+skippy) < 0 {
8790 return ErrInvalidLengthGenerated
8791 }
8792 if (iNdEx + skippy) > l {
8793 return io.ErrUnexpectedEOF
8794 }
8795 iNdEx += skippy
8796 }
8797 }
8798
8799 if iNdEx > l {
8800 return io.ErrUnexpectedEOF
8801 }
8802 return nil
8803 }
8804 func (m *JSONSchemaPropsOrBool) Unmarshal(dAtA []byte) error {
8805 l := len(dAtA)
8806 iNdEx := 0
8807 for iNdEx < l {
8808 preIndex := iNdEx
8809 var wire uint64
8810 for shift := uint(0); ; shift += 7 {
8811 if shift >= 64 {
8812 return ErrIntOverflowGenerated
8813 }
8814 if iNdEx >= l {
8815 return io.ErrUnexpectedEOF
8816 }
8817 b := dAtA[iNdEx]
8818 iNdEx++
8819 wire |= uint64(b&0x7F) << shift
8820 if b < 0x80 {
8821 break
8822 }
8823 }
8824 fieldNum := int32(wire >> 3)
8825 wireType := int(wire & 0x7)
8826 if wireType == 4 {
8827 return fmt.Errorf("proto: JSONSchemaPropsOrBool: wiretype end group for non-group")
8828 }
8829 if fieldNum <= 0 {
8830 return fmt.Errorf("proto: JSONSchemaPropsOrBool: illegal tag %d (wire type %d)", fieldNum, wire)
8831 }
8832 switch fieldNum {
8833 case 1:
8834 if wireType != 0 {
8835 return fmt.Errorf("proto: wrong wireType = %d for field Allows", wireType)
8836 }
8837 var v int
8838 for shift := uint(0); ; shift += 7 {
8839 if shift >= 64 {
8840 return ErrIntOverflowGenerated
8841 }
8842 if iNdEx >= l {
8843 return io.ErrUnexpectedEOF
8844 }
8845 b := dAtA[iNdEx]
8846 iNdEx++
8847 v |= int(b&0x7F) << shift
8848 if b < 0x80 {
8849 break
8850 }
8851 }
8852 m.Allows = bool(v != 0)
8853 case 2:
8854 if wireType != 2 {
8855 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
8856 }
8857 var msglen int
8858 for shift := uint(0); ; shift += 7 {
8859 if shift >= 64 {
8860 return ErrIntOverflowGenerated
8861 }
8862 if iNdEx >= l {
8863 return io.ErrUnexpectedEOF
8864 }
8865 b := dAtA[iNdEx]
8866 iNdEx++
8867 msglen |= int(b&0x7F) << shift
8868 if b < 0x80 {
8869 break
8870 }
8871 }
8872 if msglen < 0 {
8873 return ErrInvalidLengthGenerated
8874 }
8875 postIndex := iNdEx + msglen
8876 if postIndex < 0 {
8877 return ErrInvalidLengthGenerated
8878 }
8879 if postIndex > l {
8880 return io.ErrUnexpectedEOF
8881 }
8882 if m.Schema == nil {
8883 m.Schema = &JSONSchemaProps{}
8884 }
8885 if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8886 return err
8887 }
8888 iNdEx = postIndex
8889 default:
8890 iNdEx = preIndex
8891 skippy, err := skipGenerated(dAtA[iNdEx:])
8892 if err != nil {
8893 return err
8894 }
8895 if (skippy < 0) || (iNdEx+skippy) < 0 {
8896 return ErrInvalidLengthGenerated
8897 }
8898 if (iNdEx + skippy) > l {
8899 return io.ErrUnexpectedEOF
8900 }
8901 iNdEx += skippy
8902 }
8903 }
8904
8905 if iNdEx > l {
8906 return io.ErrUnexpectedEOF
8907 }
8908 return nil
8909 }
8910 func (m *JSONSchemaPropsOrStringArray) Unmarshal(dAtA []byte) error {
8911 l := len(dAtA)
8912 iNdEx := 0
8913 for iNdEx < l {
8914 preIndex := iNdEx
8915 var wire uint64
8916 for shift := uint(0); ; shift += 7 {
8917 if shift >= 64 {
8918 return ErrIntOverflowGenerated
8919 }
8920 if iNdEx >= l {
8921 return io.ErrUnexpectedEOF
8922 }
8923 b := dAtA[iNdEx]
8924 iNdEx++
8925 wire |= uint64(b&0x7F) << shift
8926 if b < 0x80 {
8927 break
8928 }
8929 }
8930 fieldNum := int32(wire >> 3)
8931 wireType := int(wire & 0x7)
8932 if wireType == 4 {
8933 return fmt.Errorf("proto: JSONSchemaPropsOrStringArray: wiretype end group for non-group")
8934 }
8935 if fieldNum <= 0 {
8936 return fmt.Errorf("proto: JSONSchemaPropsOrStringArray: illegal tag %d (wire type %d)", fieldNum, wire)
8937 }
8938 switch fieldNum {
8939 case 1:
8940 if wireType != 2 {
8941 return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
8942 }
8943 var msglen int
8944 for shift := uint(0); ; shift += 7 {
8945 if shift >= 64 {
8946 return ErrIntOverflowGenerated
8947 }
8948 if iNdEx >= l {
8949 return io.ErrUnexpectedEOF
8950 }
8951 b := dAtA[iNdEx]
8952 iNdEx++
8953 msglen |= int(b&0x7F) << shift
8954 if b < 0x80 {
8955 break
8956 }
8957 }
8958 if msglen < 0 {
8959 return ErrInvalidLengthGenerated
8960 }
8961 postIndex := iNdEx + msglen
8962 if postIndex < 0 {
8963 return ErrInvalidLengthGenerated
8964 }
8965 if postIndex > l {
8966 return io.ErrUnexpectedEOF
8967 }
8968 if m.Schema == nil {
8969 m.Schema = &JSONSchemaProps{}
8970 }
8971 if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8972 return err
8973 }
8974 iNdEx = postIndex
8975 case 2:
8976 if wireType != 2 {
8977 return fmt.Errorf("proto: wrong wireType = %d for field Property", wireType)
8978 }
8979 var stringLen uint64
8980 for shift := uint(0); ; shift += 7 {
8981 if shift >= 64 {
8982 return ErrIntOverflowGenerated
8983 }
8984 if iNdEx >= l {
8985 return io.ErrUnexpectedEOF
8986 }
8987 b := dAtA[iNdEx]
8988 iNdEx++
8989 stringLen |= uint64(b&0x7F) << shift
8990 if b < 0x80 {
8991 break
8992 }
8993 }
8994 intStringLen := int(stringLen)
8995 if intStringLen < 0 {
8996 return ErrInvalidLengthGenerated
8997 }
8998 postIndex := iNdEx + intStringLen
8999 if postIndex < 0 {
9000 return ErrInvalidLengthGenerated
9001 }
9002 if postIndex > l {
9003 return io.ErrUnexpectedEOF
9004 }
9005 m.Property = append(m.Property, string(dAtA[iNdEx:postIndex]))
9006 iNdEx = postIndex
9007 default:
9008 iNdEx = preIndex
9009 skippy, err := skipGenerated(dAtA[iNdEx:])
9010 if err != nil {
9011 return err
9012 }
9013 if (skippy < 0) || (iNdEx+skippy) < 0 {
9014 return ErrInvalidLengthGenerated
9015 }
9016 if (iNdEx + skippy) > l {
9017 return io.ErrUnexpectedEOF
9018 }
9019 iNdEx += skippy
9020 }
9021 }
9022
9023 if iNdEx > l {
9024 return io.ErrUnexpectedEOF
9025 }
9026 return nil
9027 }
9028 func (m *SelectableField) Unmarshal(dAtA []byte) error {
9029 l := len(dAtA)
9030 iNdEx := 0
9031 for iNdEx < l {
9032 preIndex := iNdEx
9033 var wire uint64
9034 for shift := uint(0); ; shift += 7 {
9035 if shift >= 64 {
9036 return ErrIntOverflowGenerated
9037 }
9038 if iNdEx >= l {
9039 return io.ErrUnexpectedEOF
9040 }
9041 b := dAtA[iNdEx]
9042 iNdEx++
9043 wire |= uint64(b&0x7F) << shift
9044 if b < 0x80 {
9045 break
9046 }
9047 }
9048 fieldNum := int32(wire >> 3)
9049 wireType := int(wire & 0x7)
9050 if wireType == 4 {
9051 return fmt.Errorf("proto: SelectableField: wiretype end group for non-group")
9052 }
9053 if fieldNum <= 0 {
9054 return fmt.Errorf("proto: SelectableField: illegal tag %d (wire type %d)", fieldNum, wire)
9055 }
9056 switch fieldNum {
9057 case 1:
9058 if wireType != 2 {
9059 return fmt.Errorf("proto: wrong wireType = %d for field JSONPath", wireType)
9060 }
9061 var stringLen uint64
9062 for shift := uint(0); ; shift += 7 {
9063 if shift >= 64 {
9064 return ErrIntOverflowGenerated
9065 }
9066 if iNdEx >= l {
9067 return io.ErrUnexpectedEOF
9068 }
9069 b := dAtA[iNdEx]
9070 iNdEx++
9071 stringLen |= uint64(b&0x7F) << shift
9072 if b < 0x80 {
9073 break
9074 }
9075 }
9076 intStringLen := int(stringLen)
9077 if intStringLen < 0 {
9078 return ErrInvalidLengthGenerated
9079 }
9080 postIndex := iNdEx + intStringLen
9081 if postIndex < 0 {
9082 return ErrInvalidLengthGenerated
9083 }
9084 if postIndex > l {
9085 return io.ErrUnexpectedEOF
9086 }
9087 m.JSONPath = string(dAtA[iNdEx:postIndex])
9088 iNdEx = postIndex
9089 default:
9090 iNdEx = preIndex
9091 skippy, err := skipGenerated(dAtA[iNdEx:])
9092 if err != nil {
9093 return err
9094 }
9095 if (skippy < 0) || (iNdEx+skippy) < 0 {
9096 return ErrInvalidLengthGenerated
9097 }
9098 if (iNdEx + skippy) > l {
9099 return io.ErrUnexpectedEOF
9100 }
9101 iNdEx += skippy
9102 }
9103 }
9104
9105 if iNdEx > l {
9106 return io.ErrUnexpectedEOF
9107 }
9108 return nil
9109 }
9110 func (m *ServiceReference) Unmarshal(dAtA []byte) error {
9111 l := len(dAtA)
9112 iNdEx := 0
9113 for iNdEx < l {
9114 preIndex := iNdEx
9115 var wire uint64
9116 for shift := uint(0); ; shift += 7 {
9117 if shift >= 64 {
9118 return ErrIntOverflowGenerated
9119 }
9120 if iNdEx >= l {
9121 return io.ErrUnexpectedEOF
9122 }
9123 b := dAtA[iNdEx]
9124 iNdEx++
9125 wire |= uint64(b&0x7F) << shift
9126 if b < 0x80 {
9127 break
9128 }
9129 }
9130 fieldNum := int32(wire >> 3)
9131 wireType := int(wire & 0x7)
9132 if wireType == 4 {
9133 return fmt.Errorf("proto: ServiceReference: wiretype end group for non-group")
9134 }
9135 if fieldNum <= 0 {
9136 return fmt.Errorf("proto: ServiceReference: illegal tag %d (wire type %d)", fieldNum, wire)
9137 }
9138 switch fieldNum {
9139 case 1:
9140 if wireType != 2 {
9141 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
9142 }
9143 var stringLen uint64
9144 for shift := uint(0); ; shift += 7 {
9145 if shift >= 64 {
9146 return ErrIntOverflowGenerated
9147 }
9148 if iNdEx >= l {
9149 return io.ErrUnexpectedEOF
9150 }
9151 b := dAtA[iNdEx]
9152 iNdEx++
9153 stringLen |= uint64(b&0x7F) << shift
9154 if b < 0x80 {
9155 break
9156 }
9157 }
9158 intStringLen := int(stringLen)
9159 if intStringLen < 0 {
9160 return ErrInvalidLengthGenerated
9161 }
9162 postIndex := iNdEx + intStringLen
9163 if postIndex < 0 {
9164 return ErrInvalidLengthGenerated
9165 }
9166 if postIndex > l {
9167 return io.ErrUnexpectedEOF
9168 }
9169 m.Namespace = string(dAtA[iNdEx:postIndex])
9170 iNdEx = postIndex
9171 case 2:
9172 if wireType != 2 {
9173 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
9174 }
9175 var stringLen uint64
9176 for shift := uint(0); ; shift += 7 {
9177 if shift >= 64 {
9178 return ErrIntOverflowGenerated
9179 }
9180 if iNdEx >= l {
9181 return io.ErrUnexpectedEOF
9182 }
9183 b := dAtA[iNdEx]
9184 iNdEx++
9185 stringLen |= uint64(b&0x7F) << shift
9186 if b < 0x80 {
9187 break
9188 }
9189 }
9190 intStringLen := int(stringLen)
9191 if intStringLen < 0 {
9192 return ErrInvalidLengthGenerated
9193 }
9194 postIndex := iNdEx + intStringLen
9195 if postIndex < 0 {
9196 return ErrInvalidLengthGenerated
9197 }
9198 if postIndex > l {
9199 return io.ErrUnexpectedEOF
9200 }
9201 m.Name = string(dAtA[iNdEx:postIndex])
9202 iNdEx = postIndex
9203 case 3:
9204 if wireType != 2 {
9205 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
9206 }
9207 var stringLen uint64
9208 for shift := uint(0); ; shift += 7 {
9209 if shift >= 64 {
9210 return ErrIntOverflowGenerated
9211 }
9212 if iNdEx >= l {
9213 return io.ErrUnexpectedEOF
9214 }
9215 b := dAtA[iNdEx]
9216 iNdEx++
9217 stringLen |= uint64(b&0x7F) << shift
9218 if b < 0x80 {
9219 break
9220 }
9221 }
9222 intStringLen := int(stringLen)
9223 if intStringLen < 0 {
9224 return ErrInvalidLengthGenerated
9225 }
9226 postIndex := iNdEx + intStringLen
9227 if postIndex < 0 {
9228 return ErrInvalidLengthGenerated
9229 }
9230 if postIndex > l {
9231 return io.ErrUnexpectedEOF
9232 }
9233 s := string(dAtA[iNdEx:postIndex])
9234 m.Path = &s
9235 iNdEx = postIndex
9236 case 4:
9237 if wireType != 0 {
9238 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
9239 }
9240 var v int32
9241 for shift := uint(0); ; shift += 7 {
9242 if shift >= 64 {
9243 return ErrIntOverflowGenerated
9244 }
9245 if iNdEx >= l {
9246 return io.ErrUnexpectedEOF
9247 }
9248 b := dAtA[iNdEx]
9249 iNdEx++
9250 v |= int32(b&0x7F) << shift
9251 if b < 0x80 {
9252 break
9253 }
9254 }
9255 m.Port = &v
9256 default:
9257 iNdEx = preIndex
9258 skippy, err := skipGenerated(dAtA[iNdEx:])
9259 if err != nil {
9260 return err
9261 }
9262 if (skippy < 0) || (iNdEx+skippy) < 0 {
9263 return ErrInvalidLengthGenerated
9264 }
9265 if (iNdEx + skippy) > l {
9266 return io.ErrUnexpectedEOF
9267 }
9268 iNdEx += skippy
9269 }
9270 }
9271
9272 if iNdEx > l {
9273 return io.ErrUnexpectedEOF
9274 }
9275 return nil
9276 }
9277 func (m *ValidationRule) Unmarshal(dAtA []byte) error {
9278 l := len(dAtA)
9279 iNdEx := 0
9280 for iNdEx < l {
9281 preIndex := iNdEx
9282 var wire uint64
9283 for shift := uint(0); ; shift += 7 {
9284 if shift >= 64 {
9285 return ErrIntOverflowGenerated
9286 }
9287 if iNdEx >= l {
9288 return io.ErrUnexpectedEOF
9289 }
9290 b := dAtA[iNdEx]
9291 iNdEx++
9292 wire |= uint64(b&0x7F) << shift
9293 if b < 0x80 {
9294 break
9295 }
9296 }
9297 fieldNum := int32(wire >> 3)
9298 wireType := int(wire & 0x7)
9299 if wireType == 4 {
9300 return fmt.Errorf("proto: ValidationRule: wiretype end group for non-group")
9301 }
9302 if fieldNum <= 0 {
9303 return fmt.Errorf("proto: ValidationRule: illegal tag %d (wire type %d)", fieldNum, wire)
9304 }
9305 switch fieldNum {
9306 case 1:
9307 if wireType != 2 {
9308 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
9309 }
9310 var stringLen uint64
9311 for shift := uint(0); ; shift += 7 {
9312 if shift >= 64 {
9313 return ErrIntOverflowGenerated
9314 }
9315 if iNdEx >= l {
9316 return io.ErrUnexpectedEOF
9317 }
9318 b := dAtA[iNdEx]
9319 iNdEx++
9320 stringLen |= uint64(b&0x7F) << shift
9321 if b < 0x80 {
9322 break
9323 }
9324 }
9325 intStringLen := int(stringLen)
9326 if intStringLen < 0 {
9327 return ErrInvalidLengthGenerated
9328 }
9329 postIndex := iNdEx + intStringLen
9330 if postIndex < 0 {
9331 return ErrInvalidLengthGenerated
9332 }
9333 if postIndex > l {
9334 return io.ErrUnexpectedEOF
9335 }
9336 m.Rule = string(dAtA[iNdEx:postIndex])
9337 iNdEx = postIndex
9338 case 2:
9339 if wireType != 2 {
9340 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
9341 }
9342 var stringLen uint64
9343 for shift := uint(0); ; shift += 7 {
9344 if shift >= 64 {
9345 return ErrIntOverflowGenerated
9346 }
9347 if iNdEx >= l {
9348 return io.ErrUnexpectedEOF
9349 }
9350 b := dAtA[iNdEx]
9351 iNdEx++
9352 stringLen |= uint64(b&0x7F) << shift
9353 if b < 0x80 {
9354 break
9355 }
9356 }
9357 intStringLen := int(stringLen)
9358 if intStringLen < 0 {
9359 return ErrInvalidLengthGenerated
9360 }
9361 postIndex := iNdEx + intStringLen
9362 if postIndex < 0 {
9363 return ErrInvalidLengthGenerated
9364 }
9365 if postIndex > l {
9366 return io.ErrUnexpectedEOF
9367 }
9368 m.Message = string(dAtA[iNdEx:postIndex])
9369 iNdEx = postIndex
9370 case 3:
9371 if wireType != 2 {
9372 return fmt.Errorf("proto: wrong wireType = %d for field MessageExpression", wireType)
9373 }
9374 var stringLen uint64
9375 for shift := uint(0); ; shift += 7 {
9376 if shift >= 64 {
9377 return ErrIntOverflowGenerated
9378 }
9379 if iNdEx >= l {
9380 return io.ErrUnexpectedEOF
9381 }
9382 b := dAtA[iNdEx]
9383 iNdEx++
9384 stringLen |= uint64(b&0x7F) << shift
9385 if b < 0x80 {
9386 break
9387 }
9388 }
9389 intStringLen := int(stringLen)
9390 if intStringLen < 0 {
9391 return ErrInvalidLengthGenerated
9392 }
9393 postIndex := iNdEx + intStringLen
9394 if postIndex < 0 {
9395 return ErrInvalidLengthGenerated
9396 }
9397 if postIndex > l {
9398 return io.ErrUnexpectedEOF
9399 }
9400 m.MessageExpression = string(dAtA[iNdEx:postIndex])
9401 iNdEx = postIndex
9402 case 4:
9403 if wireType != 2 {
9404 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
9405 }
9406 var stringLen uint64
9407 for shift := uint(0); ; shift += 7 {
9408 if shift >= 64 {
9409 return ErrIntOverflowGenerated
9410 }
9411 if iNdEx >= l {
9412 return io.ErrUnexpectedEOF
9413 }
9414 b := dAtA[iNdEx]
9415 iNdEx++
9416 stringLen |= uint64(b&0x7F) << shift
9417 if b < 0x80 {
9418 break
9419 }
9420 }
9421 intStringLen := int(stringLen)
9422 if intStringLen < 0 {
9423 return ErrInvalidLengthGenerated
9424 }
9425 postIndex := iNdEx + intStringLen
9426 if postIndex < 0 {
9427 return ErrInvalidLengthGenerated
9428 }
9429 if postIndex > l {
9430 return io.ErrUnexpectedEOF
9431 }
9432 s := FieldValueErrorReason(dAtA[iNdEx:postIndex])
9433 m.Reason = &s
9434 iNdEx = postIndex
9435 case 5:
9436 if wireType != 2 {
9437 return fmt.Errorf("proto: wrong wireType = %d for field FieldPath", wireType)
9438 }
9439 var stringLen uint64
9440 for shift := uint(0); ; shift += 7 {
9441 if shift >= 64 {
9442 return ErrIntOverflowGenerated
9443 }
9444 if iNdEx >= l {
9445 return io.ErrUnexpectedEOF
9446 }
9447 b := dAtA[iNdEx]
9448 iNdEx++
9449 stringLen |= uint64(b&0x7F) << shift
9450 if b < 0x80 {
9451 break
9452 }
9453 }
9454 intStringLen := int(stringLen)
9455 if intStringLen < 0 {
9456 return ErrInvalidLengthGenerated
9457 }
9458 postIndex := iNdEx + intStringLen
9459 if postIndex < 0 {
9460 return ErrInvalidLengthGenerated
9461 }
9462 if postIndex > l {
9463 return io.ErrUnexpectedEOF
9464 }
9465 m.FieldPath = string(dAtA[iNdEx:postIndex])
9466 iNdEx = postIndex
9467 case 6:
9468 if wireType != 0 {
9469 return fmt.Errorf("proto: wrong wireType = %d for field OptionalOldSelf", wireType)
9470 }
9471 var v int
9472 for shift := uint(0); ; shift += 7 {
9473 if shift >= 64 {
9474 return ErrIntOverflowGenerated
9475 }
9476 if iNdEx >= l {
9477 return io.ErrUnexpectedEOF
9478 }
9479 b := dAtA[iNdEx]
9480 iNdEx++
9481 v |= int(b&0x7F) << shift
9482 if b < 0x80 {
9483 break
9484 }
9485 }
9486 b := bool(v != 0)
9487 m.OptionalOldSelf = &b
9488 default:
9489 iNdEx = preIndex
9490 skippy, err := skipGenerated(dAtA[iNdEx:])
9491 if err != nil {
9492 return err
9493 }
9494 if (skippy < 0) || (iNdEx+skippy) < 0 {
9495 return ErrInvalidLengthGenerated
9496 }
9497 if (iNdEx + skippy) > l {
9498 return io.ErrUnexpectedEOF
9499 }
9500 iNdEx += skippy
9501 }
9502 }
9503
9504 if iNdEx > l {
9505 return io.ErrUnexpectedEOF
9506 }
9507 return nil
9508 }
9509 func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error {
9510 l := len(dAtA)
9511 iNdEx := 0
9512 for iNdEx < l {
9513 preIndex := iNdEx
9514 var wire uint64
9515 for shift := uint(0); ; shift += 7 {
9516 if shift >= 64 {
9517 return ErrIntOverflowGenerated
9518 }
9519 if iNdEx >= l {
9520 return io.ErrUnexpectedEOF
9521 }
9522 b := dAtA[iNdEx]
9523 iNdEx++
9524 wire |= uint64(b&0x7F) << shift
9525 if b < 0x80 {
9526 break
9527 }
9528 }
9529 fieldNum := int32(wire >> 3)
9530 wireType := int(wire & 0x7)
9531 if wireType == 4 {
9532 return fmt.Errorf("proto: WebhookClientConfig: wiretype end group for non-group")
9533 }
9534 if fieldNum <= 0 {
9535 return fmt.Errorf("proto: WebhookClientConfig: illegal tag %d (wire type %d)", fieldNum, wire)
9536 }
9537 switch fieldNum {
9538 case 1:
9539 if wireType != 2 {
9540 return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
9541 }
9542 var msglen int
9543 for shift := uint(0); ; shift += 7 {
9544 if shift >= 64 {
9545 return ErrIntOverflowGenerated
9546 }
9547 if iNdEx >= l {
9548 return io.ErrUnexpectedEOF
9549 }
9550 b := dAtA[iNdEx]
9551 iNdEx++
9552 msglen |= int(b&0x7F) << shift
9553 if b < 0x80 {
9554 break
9555 }
9556 }
9557 if msglen < 0 {
9558 return ErrInvalidLengthGenerated
9559 }
9560 postIndex := iNdEx + msglen
9561 if postIndex < 0 {
9562 return ErrInvalidLengthGenerated
9563 }
9564 if postIndex > l {
9565 return io.ErrUnexpectedEOF
9566 }
9567 if m.Service == nil {
9568 m.Service = &ServiceReference{}
9569 }
9570 if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9571 return err
9572 }
9573 iNdEx = postIndex
9574 case 2:
9575 if wireType != 2 {
9576 return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
9577 }
9578 var byteLen int
9579 for shift := uint(0); ; shift += 7 {
9580 if shift >= 64 {
9581 return ErrIntOverflowGenerated
9582 }
9583 if iNdEx >= l {
9584 return io.ErrUnexpectedEOF
9585 }
9586 b := dAtA[iNdEx]
9587 iNdEx++
9588 byteLen |= int(b&0x7F) << shift
9589 if b < 0x80 {
9590 break
9591 }
9592 }
9593 if byteLen < 0 {
9594 return ErrInvalidLengthGenerated
9595 }
9596 postIndex := iNdEx + byteLen
9597 if postIndex < 0 {
9598 return ErrInvalidLengthGenerated
9599 }
9600 if postIndex > l {
9601 return io.ErrUnexpectedEOF
9602 }
9603 m.CABundle = append(m.CABundle[:0], dAtA[iNdEx:postIndex]...)
9604 if m.CABundle == nil {
9605 m.CABundle = []byte{}
9606 }
9607 iNdEx = postIndex
9608 case 3:
9609 if wireType != 2 {
9610 return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
9611 }
9612 var stringLen uint64
9613 for shift := uint(0); ; shift += 7 {
9614 if shift >= 64 {
9615 return ErrIntOverflowGenerated
9616 }
9617 if iNdEx >= l {
9618 return io.ErrUnexpectedEOF
9619 }
9620 b := dAtA[iNdEx]
9621 iNdEx++
9622 stringLen |= uint64(b&0x7F) << shift
9623 if b < 0x80 {
9624 break
9625 }
9626 }
9627 intStringLen := int(stringLen)
9628 if intStringLen < 0 {
9629 return ErrInvalidLengthGenerated
9630 }
9631 postIndex := iNdEx + intStringLen
9632 if postIndex < 0 {
9633 return ErrInvalidLengthGenerated
9634 }
9635 if postIndex > l {
9636 return io.ErrUnexpectedEOF
9637 }
9638 s := string(dAtA[iNdEx:postIndex])
9639 m.URL = &s
9640 iNdEx = postIndex
9641 default:
9642 iNdEx = preIndex
9643 skippy, err := skipGenerated(dAtA[iNdEx:])
9644 if err != nil {
9645 return err
9646 }
9647 if (skippy < 0) || (iNdEx+skippy) < 0 {
9648 return ErrInvalidLengthGenerated
9649 }
9650 if (iNdEx + skippy) > l {
9651 return io.ErrUnexpectedEOF
9652 }
9653 iNdEx += skippy
9654 }
9655 }
9656
9657 if iNdEx > l {
9658 return io.ErrUnexpectedEOF
9659 }
9660 return nil
9661 }
9662 func skipGenerated(dAtA []byte) (n int, err error) {
9663 l := len(dAtA)
9664 iNdEx := 0
9665 depth := 0
9666 for iNdEx < l {
9667 var wire uint64
9668 for shift := uint(0); ; shift += 7 {
9669 if shift >= 64 {
9670 return 0, ErrIntOverflowGenerated
9671 }
9672 if iNdEx >= l {
9673 return 0, io.ErrUnexpectedEOF
9674 }
9675 b := dAtA[iNdEx]
9676 iNdEx++
9677 wire |= (uint64(b) & 0x7F) << shift
9678 if b < 0x80 {
9679 break
9680 }
9681 }
9682 wireType := int(wire & 0x7)
9683 switch wireType {
9684 case 0:
9685 for shift := uint(0); ; shift += 7 {
9686 if shift >= 64 {
9687 return 0, ErrIntOverflowGenerated
9688 }
9689 if iNdEx >= l {
9690 return 0, io.ErrUnexpectedEOF
9691 }
9692 iNdEx++
9693 if dAtA[iNdEx-1] < 0x80 {
9694 break
9695 }
9696 }
9697 case 1:
9698 iNdEx += 8
9699 case 2:
9700 var length int
9701 for shift := uint(0); ; shift += 7 {
9702 if shift >= 64 {
9703 return 0, ErrIntOverflowGenerated
9704 }
9705 if iNdEx >= l {
9706 return 0, io.ErrUnexpectedEOF
9707 }
9708 b := dAtA[iNdEx]
9709 iNdEx++
9710 length |= (int(b) & 0x7F) << shift
9711 if b < 0x80 {
9712 break
9713 }
9714 }
9715 if length < 0 {
9716 return 0, ErrInvalidLengthGenerated
9717 }
9718 iNdEx += length
9719 case 3:
9720 depth++
9721 case 4:
9722 if depth == 0 {
9723 return 0, ErrUnexpectedEndOfGroupGenerated
9724 }
9725 depth--
9726 case 5:
9727 iNdEx += 4
9728 default:
9729 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
9730 }
9731 if iNdEx < 0 {
9732 return 0, ErrInvalidLengthGenerated
9733 }
9734 if depth == 0 {
9735 return iNdEx, nil
9736 }
9737 }
9738 return 0, io.ErrUnexpectedEOF
9739 }
9740
9741 var (
9742 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
9743 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
9744 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
9745 )
9746
View as plain text