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