Debian Codegraph @

envoy/config/filter/fault/v2/fault.pb.validate.go

raw
1 //go:build !disable_pgv
2 // Code generated by protoc-gen-validate. DO NOT EDIT.
3 // source: envoy/config/filter/fault/v2/fault.proto
4
5 package faultv2
6
7 import (
8 "bytes"
9 "errors"
10 "fmt"
11 "net"
12 "net/mail"
13 "net/url"
14 "regexp"
15 "sort"
16 "strings"
17 "time"
18 "unicode/utf8"
19
20 "google.golang.org/protobuf/types/known/anypb"
21 )
22
23 // ensure the imports are used
24 var (
25 _ = bytes.MinRead
26 _ = errors.New("")
27 _ = fmt.Print
28 _ = utf8.UTFMax
29 _ = (*regexp.Regexp)(nil)
30 _ = (*strings.Reader)(nil)
31 _ = net.IPv4len
32 _ = time.Duration(0)
33 _ = (*url.URL)(nil)
34 _ = (*mail.Address)(nil)
35 _ = anypb.Any{}
36 _ = sort.Sort
37 )
38
39 // Validate checks the field values on FaultDelay with the rules defined in the
40 // proto definition for this message. If any rules are violated, the first
41 // error encountered is returned, or nil if there are no violations.
42 func (m *FaultDelay) Validate() error {
43 return m.validate(false)
44 }
45
46 // ValidateAll checks the field values on FaultDelay with the rules defined in
47 // the proto definition for this message. If any rules are violated, the
48 // result is a list of violation errors wrapped in FaultDelayMultiError, or
49 // nil if none found.
50 func (m *FaultDelay) ValidateAll() error {
51 return m.validate(true)
52 }
53
54 func (m *FaultDelay) validate(all bool) error {
55 if m == nil {
56 return nil
57 }
58
59 var errors []error
60
61 // no validation rules for Type
62
63 if all {
64 switch v := interface{}(m.GetPercentage()).(type) {
65 case interface{ ValidateAll() error }:
66 if err := v.ValidateAll(); err != nil {
67 errors = append(errors, FaultDelayValidationError{
68 field: "Percentage",
69 reason: "embedded message failed validation",
70 cause: err,
71 })
72 }
73 case interface{ Validate() error }:
74 if err := v.Validate(); err != nil {
75 errors = append(errors, FaultDelayValidationError{
76 field: "Percentage",
77 reason: "embedded message failed validation",
78 cause: err,
79 })
80 }
81 }
82 } else if v, ok := interface{}(m.GetPercentage()).(interface{ Validate() error }); ok {
83 if err := v.Validate(); err != nil {
84 return FaultDelayValidationError{
85 field: "Percentage",
86 reason: "embedded message failed validation",
87 cause: err,
88 }
89 }
90 }
91
92 oneofFaultDelaySecifierPresent := false
93 switch v := m.FaultDelaySecifier.(type) {
94 case *FaultDelay_FixedDelay:
95 if v == nil {
96 err := FaultDelayValidationError{
97 field: "FaultDelaySecifier",
98 reason: "oneof value cannot be a typed-nil",
99 }
100 if !all {
101 return err
102 }
103 errors = append(errors, err)
104 }
105 oneofFaultDelaySecifierPresent = true
106
107 if d := m.GetFixedDelay(); d != nil {
108 dur, err := d.AsDuration(), d.CheckValid()
109 if err != nil {
110 err = FaultDelayValidationError{
111 field: "FixedDelay",
112 reason: "value is not a valid duration",
113 cause: err,
114 }
115 if !all {
116 return err
117 }
118 errors = append(errors, err)
119 } else {
120
121 gt := time.Duration(0*time.Second + 0*time.Nanosecond)
122
123 if dur <= gt {
124 err := FaultDelayValidationError{
125 field: "FixedDelay",
126 reason: "value must be greater than 0s",
127 }
128 if !all {
129 return err
130 }
131 errors = append(errors, err)
132 }
133
134 }
135 }
136
137 case *FaultDelay_HeaderDelay_:
138 if v == nil {
139 err := FaultDelayValidationError{
140 field: "FaultDelaySecifier",
141 reason: "oneof value cannot be a typed-nil",
142 }
143 if !all {
144 return err
145 }
146 errors = append(errors, err)
147 }
148 oneofFaultDelaySecifierPresent = true
149
150 if all {
151 switch v := interface{}(m.GetHeaderDelay()).(type) {
152 case interface{ ValidateAll() error }:
153 if err := v.ValidateAll(); err != nil {
154 errors = append(errors, FaultDelayValidationError{
155 field: "HeaderDelay",
156 reason: "embedded message failed validation",
157 cause: err,
158 })
159 }
160 case interface{ Validate() error }:
161 if err := v.Validate(); err != nil {
162 errors = append(errors, FaultDelayValidationError{
163 field: "HeaderDelay",
164 reason: "embedded message failed validation",
165 cause: err,
166 })
167 }
168 }
169 } else if v, ok := interface{}(m.GetHeaderDelay()).(interface{ Validate() error }); ok {
170 if err := v.Validate(); err != nil {
171 return FaultDelayValidationError{
172 field: "HeaderDelay",
173 reason: "embedded message failed validation",
174 cause: err,
175 }
176 }
177 }
178
179 default:
180 _ = v // ensures v is used
181 }
182 if !oneofFaultDelaySecifierPresent {
183 err := FaultDelayValidationError{
184 field: "FaultDelaySecifier",
185 reason: "value is required",
186 }
187 if !all {
188 return err
189 }
190 errors = append(errors, err)
191 }
192
193 if len(errors) > 0 {
194 return FaultDelayMultiError(errors)
195 }
196
197 return nil
198 }
199
200 // FaultDelayMultiError is an error wrapping multiple validation errors
201 // returned by FaultDelay.ValidateAll() if the designated constraints aren't met.
202 type FaultDelayMultiError []error
203
204 // Error returns a concatenation of all the error messages it wraps.
205 func (m FaultDelayMultiError) Error() string {
206 var msgs []string
207 for _, err := range m {
208 msgs = append(msgs, err.Error())
209 }
210 return strings.Join(msgs, "; ")
211 }
212
213 // AllErrors returns a list of validation violation errors.
214 func (m FaultDelayMultiError) AllErrors() []error { return m }
215
216 // FaultDelayValidationError is the validation error returned by
217 // FaultDelay.Validate if the designated constraints aren't met.
218 type FaultDelayValidationError struct {
219 field string
220 reason string
221 cause error
222 key bool
223 }
224
225 // Field function returns field value.
226 func (e FaultDelayValidationError) Field() string { return e.field }
227
228 // Reason function returns reason value.
229 func (e FaultDelayValidationError) Reason() string { return e.reason }
230
231 // Cause function returns cause value.
232 func (e FaultDelayValidationError) Cause() error { return e.cause }
233
234 // Key function returns key value.
235 func (e FaultDelayValidationError) Key() bool { return e.key }
236
237 // ErrorName returns error name.
238 func (e FaultDelayValidationError) ErrorName() string { return "FaultDelayValidationError" }
239
240 // Error satisfies the builtin error interface
241 func (e FaultDelayValidationError) Error() string {
242 cause := ""
243 if e.cause != nil {
244 cause = fmt.Sprintf(" | caused by: %v", e.cause)
245 }
246
247 key := ""
248 if e.key {
249 key = "key for "
250 }
251
252 return fmt.Sprintf(
253 "invalid %sFaultDelay.%s: %s%s",
254 key,
255 e.field,
256 e.reason,
257 cause)
258 }
259
260 var _ error = FaultDelayValidationError{}
261
262 var _ interface {
263 Field() string
264 Reason() string
265 Key() bool
266 Cause() error
267 ErrorName() string
268 } = FaultDelayValidationError{}
269
270 // Validate checks the field values on FaultRateLimit with the rules defined in
271 // the proto definition for this message. If any rules are violated, the first
272 // error encountered is returned, or nil if there are no violations.
273 func (m *FaultRateLimit) Validate() error {
274 return m.validate(false)
275 }
276
277 // ValidateAll checks the field values on FaultRateLimit with the rules defined
278 // in the proto definition for this message. If any rules are violated, the
279 // result is a list of violation errors wrapped in FaultRateLimitMultiError,
280 // or nil if none found.
281 func (m *FaultRateLimit) ValidateAll() error {
282 return m.validate(true)
283 }
284
285 func (m *FaultRateLimit) validate(all bool) error {
286 if m == nil {
287 return nil
288 }
289
290 var errors []error
291
292 if all {
293 switch v := interface{}(m.GetPercentage()).(type) {
294 case interface{ ValidateAll() error }:
295 if err := v.ValidateAll(); err != nil {
296 errors = append(errors, FaultRateLimitValidationError{
297 field: "Percentage",
298 reason: "embedded message failed validation",
299 cause: err,
300 })
301 }
302 case interface{ Validate() error }:
303 if err := v.Validate(); err != nil {
304 errors = append(errors, FaultRateLimitValidationError{
305 field: "Percentage",
306 reason: "embedded message failed validation",
307 cause: err,
308 })
309 }
310 }
311 } else if v, ok := interface{}(m.GetPercentage()).(interface{ Validate() error }); ok {
312 if err := v.Validate(); err != nil {
313 return FaultRateLimitValidationError{
314 field: "Percentage",
315 reason: "embedded message failed validation",
316 cause: err,
317 }
318 }
319 }
320
321 oneofLimitTypePresent := false
322 switch v := m.LimitType.(type) {
323 case *FaultRateLimit_FixedLimit_:
324 if v == nil {
325 err := FaultRateLimitValidationError{
326 field: "LimitType",
327 reason: "oneof value cannot be a typed-nil",
328 }
329 if !all {
330 return err
331 }
332 errors = append(errors, err)
333 }
334 oneofLimitTypePresent = true
335
336 if all {
337 switch v := interface{}(m.GetFixedLimit()).(type) {
338 case interface{ ValidateAll() error }:
339 if err := v.ValidateAll(); err != nil {
340 errors = append(errors, FaultRateLimitValidationError{
341 field: "FixedLimit",
342 reason: "embedded message failed validation",
343 cause: err,
344 })
345 }
346 case interface{ Validate() error }:
347 if err := v.Validate(); err != nil {
348 errors = append(errors, FaultRateLimitValidationError{
349 field: "FixedLimit",
350 reason: "embedded message failed validation",
351 cause: err,
352 })
353 }
354 }
355 } else if v, ok := interface{}(m.GetFixedLimit()).(interface{ Validate() error }); ok {
356 if err := v.Validate(); err != nil {
357 return FaultRateLimitValidationError{
358 field: "FixedLimit",
359 reason: "embedded message failed validation",
360 cause: err,
361 }
362 }
363 }
364
365 case *FaultRateLimit_HeaderLimit_:
366 if v == nil {
367 err := FaultRateLimitValidationError{
368 field: "LimitType",
369 reason: "oneof value cannot be a typed-nil",
370 }
371 if !all {
372 return err
373 }
374 errors = append(errors, err)
375 }
376 oneofLimitTypePresent = true
377
378 if all {
379 switch v := interface{}(m.GetHeaderLimit()).(type) {
380 case interface{ ValidateAll() error }:
381 if err := v.ValidateAll(); err != nil {
382 errors = append(errors, FaultRateLimitValidationError{
383 field: "HeaderLimit",
384 reason: "embedded message failed validation",
385 cause: err,
386 })
387 }
388 case interface{ Validate() error }:
389 if err := v.Validate(); err != nil {
390 errors = append(errors, FaultRateLimitValidationError{
391 field: "HeaderLimit",
392 reason: "embedded message failed validation",
393 cause: err,
394 })
395 }
396 }
397 } else if v, ok := interface{}(m.GetHeaderLimit()).(interface{ Validate() error }); ok {
398 if err := v.Validate(); err != nil {
399 return FaultRateLimitValidationError{
400 field: "HeaderLimit",
401 reason: "embedded message failed validation",
402 cause: err,
403 }
404 }
405 }
406
407 default:
408 _ = v // ensures v is used
409 }
410 if !oneofLimitTypePresent {
411 err := FaultRateLimitValidationError{
412 field: "LimitType",
413 reason: "value is required",
414 }
415 if !all {
416 return err
417 }
418 errors = append(errors, err)
419 }
420
421 if len(errors) > 0 {
422 return FaultRateLimitMultiError(errors)
423 }
424
425 return nil
426 }
427
428 // FaultRateLimitMultiError is an error wrapping multiple validation errors
429 // returned by FaultRateLimit.ValidateAll() if the designated constraints
430 // aren't met.
431 type FaultRateLimitMultiError []error
432
433 // Error returns a concatenation of all the error messages it wraps.
434 func (m FaultRateLimitMultiError) Error() string {
435 var msgs []string
436 for _, err := range m {
437 msgs = append(msgs, err.Error())
438 }
439 return strings.Join(msgs, "; ")
440 }
441
442 // AllErrors returns a list of validation violation errors.
443 func (m FaultRateLimitMultiError) AllErrors() []error { return m }
444
445 // FaultRateLimitValidationError is the validation error returned by
446 // FaultRateLimit.Validate if the designated constraints aren't met.
447 type FaultRateLimitValidationError struct {
448 field string
449 reason string
450 cause error
451 key bool
452 }
453
454 // Field function returns field value.
455 func (e FaultRateLimitValidationError) Field() string { return e.field }
456
457 // Reason function returns reason value.
458 func (e FaultRateLimitValidationError) Reason() string { return e.reason }
459
460 // Cause function returns cause value.
461 func (e FaultRateLimitValidationError) Cause() error { return e.cause }
462
463 // Key function returns key value.
464 func (e FaultRateLimitValidationError) Key() bool { return e.key }
465
466 // ErrorName returns error name.
467 func (e FaultRateLimitValidationError) ErrorName() string { return "FaultRateLimitValidationError" }
468
469 // Error satisfies the builtin error interface
470 func (e FaultRateLimitValidationError) Error() string {
471 cause := ""
472 if e.cause != nil {
473 cause = fmt.Sprintf(" | caused by: %v", e.cause)
474 }
475
476 key := ""
477 if e.key {
478 key = "key for "
479 }
480
481 return fmt.Sprintf(
482 "invalid %sFaultRateLimit.%s: %s%s",
483 key,
484 e.field,
485 e.reason,
486 cause)
487 }
488
489 var _ error = FaultRateLimitValidationError{}
490
491 var _ interface {
492 Field() string
493 Reason() string
494 Key() bool
495 Cause() error
496 ErrorName() string
497 } = FaultRateLimitValidationError{}
498
499 // Validate checks the field values on FaultDelay_HeaderDelay with the rules
500 // defined in the proto definition for this message. If any rules are
501 // violated, the first error encountered is returned, or nil if there are no violations.
502 func (m *FaultDelay_HeaderDelay) Validate() error {
503 return m.validate(false)
504 }
505
506 // ValidateAll checks the field values on FaultDelay_HeaderDelay with the rules
507 // defined in the proto definition for this message. If any rules are
508 // violated, the result is a list of violation errors wrapped in
509 // FaultDelay_HeaderDelayMultiError, or nil if none found.
510 func (m *FaultDelay_HeaderDelay) ValidateAll() error {
511 return m.validate(true)
512 }
513
514 func (m *FaultDelay_HeaderDelay) validate(all bool) error {
515 if m == nil {
516 return nil
517 }
518
519 var errors []error
520
521 if len(errors) > 0 {
522 return FaultDelay_HeaderDelayMultiError(errors)
523 }
524
525 return nil
526 }
527
528 // FaultDelay_HeaderDelayMultiError is an error wrapping multiple validation
529 // errors returned by FaultDelay_HeaderDelay.ValidateAll() if the designated
530 // constraints aren't met.
531 type FaultDelay_HeaderDelayMultiError []error
532
533 // Error returns a concatenation of all the error messages it wraps.
534 func (m FaultDelay_HeaderDelayMultiError) Error() string {
535 var msgs []string
536 for _, err := range m {
537 msgs = append(msgs, err.Error())
538 }
539 return strings.Join(msgs, "; ")
540 }
541
542 // AllErrors returns a list of validation violation errors.
543 func (m FaultDelay_HeaderDelayMultiError) AllErrors() []error { return m }
544
545 // FaultDelay_HeaderDelayValidationError is the validation error returned by
546 // FaultDelay_HeaderDelay.Validate if the designated constraints aren't met.
547 type FaultDelay_HeaderDelayValidationError struct {
548 field string
549 reason string
550 cause error
551 key bool
552 }
553
554 // Field function returns field value.
555 func (e FaultDelay_HeaderDelayValidationError) Field() string { return e.field }
556
557 // Reason function returns reason value.
558 func (e FaultDelay_HeaderDelayValidationError) Reason() string { return e.reason }
559
560 // Cause function returns cause value.
561 func (e FaultDelay_HeaderDelayValidationError) Cause() error { return e.cause }
562
563 // Key function returns key value.
564 func (e FaultDelay_HeaderDelayValidationError) Key() bool { return e.key }
565
566 // ErrorName returns error name.
567 func (e FaultDelay_HeaderDelayValidationError) ErrorName() string {
568 return "FaultDelay_HeaderDelayValidationError"
569 }
570
571 // Error satisfies the builtin error interface
572 func (e FaultDelay_HeaderDelayValidationError) Error() string {
573 cause := ""
574 if e.cause != nil {
575 cause = fmt.Sprintf(" | caused by: %v", e.cause)
576 }
577
578 key := ""
579 if e.key {
580 key = "key for "
581 }
582
583 return fmt.Sprintf(
584 "invalid %sFaultDelay_HeaderDelay.%s: %s%s",
585 key,
586 e.field,
587 e.reason,
588 cause)
589 }
590
591 var _ error = FaultDelay_HeaderDelayValidationError{}
592
593 var _ interface {
594 Field() string
595 Reason() string
596 Key() bool
597 Cause() error
598 ErrorName() string
599 } = FaultDelay_HeaderDelayValidationError{}
600
601 // Validate checks the field values on FaultRateLimit_FixedLimit with the rules
602 // defined in the proto definition for this message. If any rules are
603 // violated, the first error encountered is returned, or nil if there are no violations.
604 func (m *FaultRateLimit_FixedLimit) Validate() error {
605 return m.validate(false)
606 }
607
608 // ValidateAll checks the field values on FaultRateLimit_FixedLimit with the
609 // rules defined in the proto definition for this message. If any rules are
610 // violated, the result is a list of violation errors wrapped in
611 // FaultRateLimit_FixedLimitMultiError, or nil if none found.
612 func (m *FaultRateLimit_FixedLimit) ValidateAll() error {
613 return m.validate(true)
614 }
615
616 func (m *FaultRateLimit_FixedLimit) validate(all bool) error {
617 if m == nil {
618 return nil
619 }
620
621 var errors []error
622
623 if m.GetLimitKbps() < 1 {
624 err := FaultRateLimit_FixedLimitValidationError{
625 field: "LimitKbps",
626 reason: "value must be greater than or equal to 1",
627 }
628 if !all {
629 return err
630 }
631 errors = append(errors, err)
632 }
633
634 if len(errors) > 0 {
635 return FaultRateLimit_FixedLimitMultiError(errors)
636 }
637
638 return nil
639 }
640
641 // FaultRateLimit_FixedLimitMultiError is an error wrapping multiple validation
642 // errors returned by FaultRateLimit_FixedLimit.ValidateAll() if the
643 // designated constraints aren't met.
644 type FaultRateLimit_FixedLimitMultiError []error
645
646 // Error returns a concatenation of all the error messages it wraps.
647 func (m FaultRateLimit_FixedLimitMultiError) Error() string {
648 var msgs []string
649 for _, err := range m {
650 msgs = append(msgs, err.Error())
651 }
652 return strings.Join(msgs, "; ")
653 }
654
655 // AllErrors returns a list of validation violation errors.
656 func (m FaultRateLimit_FixedLimitMultiError) AllErrors() []error { return m }
657
658 // FaultRateLimit_FixedLimitValidationError is the validation error returned by
659 // FaultRateLimit_FixedLimit.Validate if the designated constraints aren't met.
660 type FaultRateLimit_FixedLimitValidationError struct {
661 field string
662 reason string
663 cause error
664 key bool
665 }
666
667 // Field function returns field value.
668 func (e FaultRateLimit_FixedLimitValidationError) Field() string { return e.field }
669
670 // Reason function returns reason value.
671 func (e FaultRateLimit_FixedLimitValidationError) Reason() string { return e.reason }
672
673 // Cause function returns cause value.
674 func (e FaultRateLimit_FixedLimitValidationError) Cause() error { return e.cause }
675
676 // Key function returns key value.
677 func (e FaultRateLimit_FixedLimitValidationError) Key() bool { return e.key }
678
679 // ErrorName returns error name.
680 func (e FaultRateLimit_FixedLimitValidationError) ErrorName() string {
681 return "FaultRateLimit_FixedLimitValidationError"
682 }
683
684 // Error satisfies the builtin error interface
685 func (e FaultRateLimit_FixedLimitValidationError) Error() string {
686 cause := ""
687 if e.cause != nil {
688 cause = fmt.Sprintf(" | caused by: %v", e.cause)
689 }
690
691 key := ""
692 if e.key {
693 key = "key for "
694 }
695
696 return fmt.Sprintf(
697 "invalid %sFaultRateLimit_FixedLimit.%s: %s%s",
698 key,
699 e.field,
700 e.reason,
701 cause)
702 }
703
704 var _ error = FaultRateLimit_FixedLimitValidationError{}
705
706 var _ interface {
707 Field() string
708 Reason() string
709 Key() bool
710 Cause() error
711 ErrorName() string
712 } = FaultRateLimit_FixedLimitValidationError{}
713
714 // Validate checks the field values on FaultRateLimit_HeaderLimit with the
715 // rules defined in the proto definition for this message. If any rules are
716 // violated, the first error encountered is returned, or nil if there are no violations.
717 func (m *FaultRateLimit_HeaderLimit) Validate() error {
718 return m.validate(false)
719 }
720
721 // ValidateAll checks the field values on FaultRateLimit_HeaderLimit with the
722 // rules defined in the proto definition for this message. If any rules are
723 // violated, the result is a list of violation errors wrapped in
724 // FaultRateLimit_HeaderLimitMultiError, or nil if none found.
725 func (m *FaultRateLimit_HeaderLimit) ValidateAll() error {
726 return m.validate(true)
727 }
728
729 func (m *FaultRateLimit_HeaderLimit) validate(all bool) error {
730 if m == nil {
731 return nil
732 }
733
734 var errors []error
735
736 if len(errors) > 0 {
737 return FaultRateLimit_HeaderLimitMultiError(errors)
738 }
739
740 return nil
741 }
742
743 // FaultRateLimit_HeaderLimitMultiError is an error wrapping multiple
744 // validation errors returned by FaultRateLimit_HeaderLimit.ValidateAll() if
745 // the designated constraints aren't met.
746 type FaultRateLimit_HeaderLimitMultiError []error
747
748 // Error returns a concatenation of all the error messages it wraps.
749 func (m FaultRateLimit_HeaderLimitMultiError) Error() string {
750 var msgs []string
751 for _, err := range m {
752 msgs = append(msgs, err.Error())
753 }
754 return strings.Join(msgs, "; ")
755 }
756
757 // AllErrors returns a list of validation violation errors.
758 func (m FaultRateLimit_HeaderLimitMultiError) AllErrors() []error { return m }
759
760 // FaultRateLimit_HeaderLimitValidationError is the validation error returned
761 // by FaultRateLimit_HeaderLimit.Validate if the designated constraints aren't met.
762 type FaultRateLimit_HeaderLimitValidationError struct {
763 field string
764 reason string
765 cause error
766 key bool
767 }
768
769 // Field function returns field value.
770 func (e FaultRateLimit_HeaderLimitValidationError) Field() string { return e.field }
771
772 // Reason function returns reason value.
773 func (e FaultRateLimit_HeaderLimitValidationError) Reason() string { return e.reason }
774
775 // Cause function returns cause value.
776 func (e FaultRateLimit_HeaderLimitValidationError) Cause() error { return e.cause }
777
778 // Key function returns key value.
779 func (e FaultRateLimit_HeaderLimitValidationError) Key() bool { return e.key }
780
781 // ErrorName returns error name.
782 func (e FaultRateLimit_HeaderLimitValidationError) ErrorName() string {
783 return "FaultRateLimit_HeaderLimitValidationError"
784 }
785
786 // Error satisfies the builtin error interface
787 func (e FaultRateLimit_HeaderLimitValidationError) Error() string {
788 cause := ""
789 if e.cause != nil {
790 cause = fmt.Sprintf(" | caused by: %v", e.cause)
791 }
792
793 key := ""
794 if e.key {
795 key = "key for "
796 }
797
798 return fmt.Sprintf(
799 "invalid %sFaultRateLimit_HeaderLimit.%s: %s%s",
800 key,
801 e.field,
802 e.reason,
803 cause)
804 }
805
806 var _ error = FaultRateLimit_HeaderLimitValidationError{}
807
808 var _ interface {
809 Field() string
810 Reason() string
811 Key() bool
812 Cause() error
813 ErrorName() string
814 } = FaultRateLimit_HeaderLimitValidationError{}