1#![allow(clippy::all)]
4
5#[derive(Clone, Copy, PartialEq, Eq, Debug)]
6pub enum Seg {
7 Fixed(&'static str),
8 Label(&'static str),
9 Greedy(&'static str),
10}
11
12#[derive(Clone, Copy, PartialEq, Eq, Debug)]
13pub enum K {
14 Str,
15 Int,
16 Num,
17 Bool,
18 Blob,
19 Ts,
20 List,
21 Map,
22 Struct,
23}
24
25#[derive(Clone, Copy, PartialEq, Eq, Debug)]
26pub enum Src {
27 Label,
28 Query,
29 Header,
30 Body,
31}
32
33#[derive(Clone, Copy, PartialEq, Eq, Debug)]
34pub enum Verb {
35 Create,
36 Get,
37 List,
38 Update,
39 Delete,
40 Action,
41}
42
43pub struct Rule {
44 pub wire: &'static str,
45 pub src: Src,
46 pub req: bool,
47 pub kind: K,
48 pub min_len: Option<u64>,
49 pub max_len: Option<u64>,
50 pub min_val: Option<i64>,
51 pub max_val: Option<i64>,
52 pub enums: &'static [&'static str],
53}
54
55pub struct OpMeta {
56 pub op: &'static str,
57 pub method: &'static str,
58 pub segs: &'static [Seg],
59 pub verb: Verb,
60 pub rtype: &'static str,
61 pub nlabels: usize,
62 pub has_input: bool,
63 pub errors: &'static [&'static str],
64 pub rules: &'static [Rule],
65 pub omembers: &'static [(&'static str, K)],
66 pub list_field: Option<&'static str>,
67 pub list_elems: &'static [(&'static str, K)],
68 pub list_scalar: bool,
69 pub req_payload: bool,
70}
71
72pub static OPS: &[OpMeta] = &[
73 OpMeta {
74 op: "AcceptCertificateTransfer",
75 method: "PATCH",
76 segs: &[
77 Seg::Fixed("accept-certificate-transfer"),
78 Seg::Label("certificateId"),
79 ],
80 verb: Verb::Action,
81 rtype: "accept-certificate-transfer",
82 nlabels: 1,
83 has_input: true,
84 errors: &[
85 "InternalFailureException",
86 "InvalidRequestException",
87 "ResourceNotFoundException",
88 "ServiceUnavailableException",
89 "ThrottlingException",
90 "TransferAlreadyCompletedException",
91 "UnauthorizedException",
92 ],
93 rules: &[Rule {
94 wire: "certificateId",
95 src: Src::Label,
96 req: true,
97 kind: K::Str,
98 min_len: Some(64),
99 max_len: Some(64),
100 min_val: None,
101 max_val: None,
102 enums: &[],
103 }],
104 omembers: &[],
105 list_field: None,
106 list_elems: &[],
107 list_scalar: false,
108 req_payload: false,
109 },
110 OpMeta {
111 op: "AddThingToBillingGroup",
112 method: "PUT",
113 segs: &[
114 Seg::Fixed("billing-groups"),
115 Seg::Fixed("addThingToBillingGroup"),
116 ],
117 verb: Verb::Action,
118 rtype: "billing-groups",
119 nlabels: 0,
120 has_input: true,
121 errors: &[
122 "InternalFailureException",
123 "InvalidRequestException",
124 "ResourceNotFoundException",
125 "ThrottlingException",
126 ],
127 rules: &[
128 Rule {
129 wire: "billingGroupName",
130 src: Src::Body,
131 req: false,
132 kind: K::Str,
133 min_len: Some(1),
134 max_len: Some(128),
135 min_val: None,
136 max_val: None,
137 enums: &[],
138 },
139 Rule {
140 wire: "thingName",
141 src: Src::Body,
142 req: false,
143 kind: K::Str,
144 min_len: Some(1),
145 max_len: Some(128),
146 min_val: None,
147 max_val: None,
148 enums: &[],
149 },
150 ],
151 omembers: &[],
152 list_field: None,
153 list_elems: &[],
154 list_scalar: false,
155 req_payload: false,
156 },
157 OpMeta {
158 op: "AddThingToThingGroup",
159 method: "PUT",
160 segs: &[
161 Seg::Fixed("thing-groups"),
162 Seg::Fixed("addThingToThingGroup"),
163 ],
164 verb: Verb::Action,
165 rtype: "thing-groups",
166 nlabels: 0,
167 has_input: true,
168 errors: &[
169 "InternalFailureException",
170 "InvalidRequestException",
171 "ResourceNotFoundException",
172 "ThrottlingException",
173 ],
174 rules: &[
175 Rule {
176 wire: "thingGroupName",
177 src: Src::Body,
178 req: false,
179 kind: K::Str,
180 min_len: Some(1),
181 max_len: Some(128),
182 min_val: None,
183 max_val: None,
184 enums: &[],
185 },
186 Rule {
187 wire: "thingName",
188 src: Src::Body,
189 req: false,
190 kind: K::Str,
191 min_len: Some(1),
192 max_len: Some(128),
193 min_val: None,
194 max_val: None,
195 enums: &[],
196 },
197 ],
198 omembers: &[],
199 list_field: None,
200 list_elems: &[],
201 list_scalar: false,
202 req_payload: false,
203 },
204 OpMeta {
205 op: "AssociateSbomWithPackageVersion",
206 method: "PUT",
207 segs: &[
208 Seg::Fixed("packages"),
209 Seg::Label("packageName"),
210 Seg::Fixed("versions"),
211 Seg::Label("versionName"),
212 Seg::Fixed("sbom"),
213 ],
214 verb: Verb::Action,
215 rtype: "packages",
216 nlabels: 2,
217 has_input: true,
218 errors: &[
219 "ConflictException",
220 "InternalServerException",
221 "ResourceNotFoundException",
222 "ServiceQuotaExceededException",
223 "ThrottlingException",
224 "ValidationException",
225 ],
226 rules: &[
227 Rule {
228 wire: "packageName",
229 src: Src::Label,
230 req: true,
231 kind: K::Str,
232 min_len: Some(1),
233 max_len: Some(128),
234 min_val: None,
235 max_val: None,
236 enums: &[],
237 },
238 Rule {
239 wire: "versionName",
240 src: Src::Label,
241 req: true,
242 kind: K::Str,
243 min_len: Some(1),
244 max_len: Some(64),
245 min_val: None,
246 max_val: None,
247 enums: &[],
248 },
249 Rule {
250 wire: "sbom",
251 src: Src::Body,
252 req: true,
253 kind: K::Struct,
254 min_len: None,
255 max_len: None,
256 min_val: None,
257 max_val: None,
258 enums: &[],
259 },
260 Rule {
261 wire: "clientToken",
262 src: Src::Query,
263 req: false,
264 kind: K::Str,
265 min_len: Some(36),
266 max_len: Some(64),
267 min_val: None,
268 max_val: None,
269 enums: &[],
270 },
271 ],
272 omembers: &[
273 ("packageName", K::Str),
274 ("versionName", K::Str),
275 ("sbom", K::Struct),
276 ("sbomValidationStatus", K::Str),
277 ],
278 list_field: None,
279 list_elems: &[],
280 list_scalar: false,
281 req_payload: false,
282 },
283 OpMeta {
284 op: "AssociateTargetsWithJob",
285 method: "POST",
286 segs: &[
287 Seg::Fixed("jobs"),
288 Seg::Label("jobId"),
289 Seg::Fixed("targets"),
290 ],
291 verb: Verb::Action,
292 rtype: "jobs",
293 nlabels: 1,
294 has_input: true,
295 errors: &[
296 "InvalidRequestException",
297 "LimitExceededException",
298 "ResourceNotFoundException",
299 "ServiceUnavailableException",
300 "ThrottlingException",
301 ],
302 rules: &[
303 Rule {
304 wire: "targets",
305 src: Src::Body,
306 req: true,
307 kind: K::List,
308 min_len: Some(1),
309 max_len: None,
310 min_val: None,
311 max_val: None,
312 enums: &[],
313 },
314 Rule {
315 wire: "jobId",
316 src: Src::Label,
317 req: true,
318 kind: K::Str,
319 min_len: Some(1),
320 max_len: Some(64),
321 min_val: None,
322 max_val: None,
323 enums: &[],
324 },
325 Rule {
326 wire: "comment",
327 src: Src::Body,
328 req: false,
329 kind: K::Str,
330 min_len: Some(0),
331 max_len: Some(2028),
332 min_val: None,
333 max_val: None,
334 enums: &[],
335 },
336 ],
337 omembers: &[
338 ("jobArn", K::Str),
339 ("jobId", K::Str),
340 ("description", K::Str),
341 ],
342 list_field: None,
343 list_elems: &[],
344 list_scalar: false,
345 req_payload: false,
346 },
347 OpMeta {
348 op: "AttachPolicy",
349 method: "PUT",
350 segs: &[Seg::Fixed("target-policies"), Seg::Label("policyName")],
351 verb: Verb::Action,
352 rtype: "target-policies",
353 nlabels: 1,
354 has_input: true,
355 errors: &[
356 "InternalFailureException",
357 "InvalidRequestException",
358 "LimitExceededException",
359 "ResourceNotFoundException",
360 "ServiceUnavailableException",
361 "ThrottlingException",
362 "UnauthorizedException",
363 ],
364 rules: &[
365 Rule {
366 wire: "policyName",
367 src: Src::Label,
368 req: true,
369 kind: K::Str,
370 min_len: Some(1),
371 max_len: Some(128),
372 min_val: None,
373 max_val: None,
374 enums: &[],
375 },
376 Rule {
377 wire: "target",
378 src: Src::Body,
379 req: true,
380 kind: K::Str,
381 min_len: None,
382 max_len: None,
383 min_val: None,
384 max_val: None,
385 enums: &[],
386 },
387 ],
388 omembers: &[],
389 list_field: None,
390 list_elems: &[],
391 list_scalar: false,
392 req_payload: false,
393 },
394 OpMeta {
395 op: "AttachPrincipalPolicy",
396 method: "PUT",
397 segs: &[Seg::Fixed("principal-policies"), Seg::Label("policyName")],
398 verb: Verb::Action,
399 rtype: "principal-policies",
400 nlabels: 1,
401 has_input: true,
402 errors: &[
403 "InternalFailureException",
404 "InvalidRequestException",
405 "LimitExceededException",
406 "ResourceNotFoundException",
407 "ServiceUnavailableException",
408 "ThrottlingException",
409 "UnauthorizedException",
410 ],
411 rules: &[
412 Rule {
413 wire: "policyName",
414 src: Src::Label,
415 req: true,
416 kind: K::Str,
417 min_len: Some(1),
418 max_len: Some(128),
419 min_val: None,
420 max_val: None,
421 enums: &[],
422 },
423 Rule {
424 wire: "x-amzn-iot-principal",
425 src: Src::Header,
426 req: true,
427 kind: K::Str,
428 min_len: None,
429 max_len: None,
430 min_val: None,
431 max_val: None,
432 enums: &[],
433 },
434 ],
435 omembers: &[],
436 list_field: None,
437 list_elems: &[],
438 list_scalar: false,
439 req_payload: false,
440 },
441 OpMeta {
442 op: "AttachSecurityProfile",
443 method: "PUT",
444 segs: &[
445 Seg::Fixed("security-profiles"),
446 Seg::Label("securityProfileName"),
447 Seg::Fixed("targets"),
448 ],
449 verb: Verb::Action,
450 rtype: "security-profiles",
451 nlabels: 1,
452 has_input: true,
453 errors: &[
454 "InternalFailureException",
455 "InvalidRequestException",
456 "LimitExceededException",
457 "ResourceNotFoundException",
458 "ThrottlingException",
459 "VersionConflictException",
460 ],
461 rules: &[
462 Rule {
463 wire: "securityProfileName",
464 src: Src::Label,
465 req: true,
466 kind: K::Str,
467 min_len: Some(1),
468 max_len: Some(128),
469 min_val: None,
470 max_val: None,
471 enums: &[],
472 },
473 Rule {
474 wire: "securityProfileTargetArn",
475 src: Src::Query,
476 req: true,
477 kind: K::Str,
478 min_len: None,
479 max_len: None,
480 min_val: None,
481 max_val: None,
482 enums: &[],
483 },
484 ],
485 omembers: &[],
486 list_field: None,
487 list_elems: &[],
488 list_scalar: false,
489 req_payload: false,
490 },
491 OpMeta {
492 op: "AttachThingPrincipal",
493 method: "PUT",
494 segs: &[
495 Seg::Fixed("things"),
496 Seg::Label("thingName"),
497 Seg::Fixed("principals"),
498 ],
499 verb: Verb::Action,
500 rtype: "things",
501 nlabels: 1,
502 has_input: true,
503 errors: &[
504 "InternalFailureException",
505 "InvalidRequestException",
506 "ResourceNotFoundException",
507 "ServiceUnavailableException",
508 "ThrottlingException",
509 "UnauthorizedException",
510 ],
511 rules: &[
512 Rule {
513 wire: "thingName",
514 src: Src::Label,
515 req: true,
516 kind: K::Str,
517 min_len: Some(1),
518 max_len: Some(128),
519 min_val: None,
520 max_val: None,
521 enums: &[],
522 },
523 Rule {
524 wire: "x-amzn-principal",
525 src: Src::Header,
526 req: true,
527 kind: K::Str,
528 min_len: None,
529 max_len: None,
530 min_val: None,
531 max_val: None,
532 enums: &[],
533 },
534 Rule {
535 wire: "thingPrincipalType",
536 src: Src::Query,
537 req: false,
538 kind: K::Str,
539 min_len: None,
540 max_len: None,
541 min_val: None,
542 max_val: None,
543 enums: &["EXCLUSIVE_THING", "NON_EXCLUSIVE_THING"],
544 },
545 ],
546 omembers: &[],
547 list_field: None,
548 list_elems: &[],
549 list_scalar: false,
550 req_payload: false,
551 },
552 OpMeta {
553 op: "CancelAuditMitigationActionsTask",
554 method: "PUT",
555 segs: &[
556 Seg::Fixed("audit"),
557 Seg::Fixed("mitigationactions"),
558 Seg::Fixed("tasks"),
559 Seg::Label("taskId"),
560 Seg::Fixed("cancel"),
561 ],
562 verb: Verb::Action,
563 rtype: "audit",
564 nlabels: 1,
565 has_input: true,
566 errors: &[
567 "InternalFailureException",
568 "InvalidRequestException",
569 "ResourceNotFoundException",
570 "ThrottlingException",
571 ],
572 rules: &[Rule {
573 wire: "taskId",
574 src: Src::Label,
575 req: true,
576 kind: K::Str,
577 min_len: Some(1),
578 max_len: Some(128),
579 min_val: None,
580 max_val: None,
581 enums: &[],
582 }],
583 omembers: &[],
584 list_field: None,
585 list_elems: &[],
586 list_scalar: false,
587 req_payload: false,
588 },
589 OpMeta {
590 op: "CancelAuditTask",
591 method: "PUT",
592 segs: &[
593 Seg::Fixed("audit"),
594 Seg::Fixed("tasks"),
595 Seg::Label("taskId"),
596 Seg::Fixed("cancel"),
597 ],
598 verb: Verb::Action,
599 rtype: "audit",
600 nlabels: 1,
601 has_input: true,
602 errors: &[
603 "InternalFailureException",
604 "InvalidRequestException",
605 "ResourceNotFoundException",
606 "ThrottlingException",
607 ],
608 rules: &[Rule {
609 wire: "taskId",
610 src: Src::Label,
611 req: true,
612 kind: K::Str,
613 min_len: Some(1),
614 max_len: Some(40),
615 min_val: None,
616 max_val: None,
617 enums: &[],
618 }],
619 omembers: &[],
620 list_field: None,
621 list_elems: &[],
622 list_scalar: false,
623 req_payload: false,
624 },
625 OpMeta {
626 op: "CancelCertificateTransfer",
627 method: "PATCH",
628 segs: &[
629 Seg::Fixed("cancel-certificate-transfer"),
630 Seg::Label("certificateId"),
631 ],
632 verb: Verb::Action,
633 rtype: "cancel-certificate-transfer",
634 nlabels: 1,
635 has_input: true,
636 errors: &[
637 "InternalFailureException",
638 "InvalidRequestException",
639 "ResourceNotFoundException",
640 "ServiceUnavailableException",
641 "ThrottlingException",
642 "TransferAlreadyCompletedException",
643 "UnauthorizedException",
644 ],
645 rules: &[Rule {
646 wire: "certificateId",
647 src: Src::Label,
648 req: true,
649 kind: K::Str,
650 min_len: Some(64),
651 max_len: Some(64),
652 min_val: None,
653 max_val: None,
654 enums: &[],
655 }],
656 omembers: &[],
657 list_field: None,
658 list_elems: &[],
659 list_scalar: false,
660 req_payload: false,
661 },
662 OpMeta {
663 op: "CancelDetectMitigationActionsTask",
664 method: "PUT",
665 segs: &[
666 Seg::Fixed("detect"),
667 Seg::Fixed("mitigationactions"),
668 Seg::Fixed("tasks"),
669 Seg::Label("taskId"),
670 Seg::Fixed("cancel"),
671 ],
672 verb: Verb::Action,
673 rtype: "detect",
674 nlabels: 1,
675 has_input: true,
676 errors: &[
677 "InternalFailureException",
678 "InvalidRequestException",
679 "ResourceNotFoundException",
680 "ThrottlingException",
681 ],
682 rules: &[Rule {
683 wire: "taskId",
684 src: Src::Label,
685 req: true,
686 kind: K::Str,
687 min_len: Some(1),
688 max_len: Some(128),
689 min_val: None,
690 max_val: None,
691 enums: &[],
692 }],
693 omembers: &[],
694 list_field: None,
695 list_elems: &[],
696 list_scalar: false,
697 req_payload: false,
698 },
699 OpMeta {
700 op: "CancelJob",
701 method: "PUT",
702 segs: &[
703 Seg::Fixed("jobs"),
704 Seg::Label("jobId"),
705 Seg::Fixed("cancel"),
706 ],
707 verb: Verb::Action,
708 rtype: "jobs",
709 nlabels: 1,
710 has_input: true,
711 errors: &[
712 "InvalidRequestException",
713 "LimitExceededException",
714 "ResourceNotFoundException",
715 "ServiceUnavailableException",
716 "ThrottlingException",
717 ],
718 rules: &[
719 Rule {
720 wire: "jobId",
721 src: Src::Label,
722 req: true,
723 kind: K::Str,
724 min_len: Some(1),
725 max_len: Some(64),
726 min_val: None,
727 max_val: None,
728 enums: &[],
729 },
730 Rule {
731 wire: "reasonCode",
732 src: Src::Body,
733 req: false,
734 kind: K::Str,
735 min_len: Some(0),
736 max_len: Some(128),
737 min_val: None,
738 max_val: None,
739 enums: &[],
740 },
741 Rule {
742 wire: "comment",
743 src: Src::Body,
744 req: false,
745 kind: K::Str,
746 min_len: Some(0),
747 max_len: Some(2028),
748 min_val: None,
749 max_val: None,
750 enums: &[],
751 },
752 ],
753 omembers: &[
754 ("jobArn", K::Str),
755 ("jobId", K::Str),
756 ("description", K::Str),
757 ],
758 list_field: None,
759 list_elems: &[],
760 list_scalar: false,
761 req_payload: false,
762 },
763 OpMeta {
764 op: "CancelJobExecution",
765 method: "PUT",
766 segs: &[
767 Seg::Fixed("things"),
768 Seg::Label("thingName"),
769 Seg::Fixed("jobs"),
770 Seg::Label("jobId"),
771 Seg::Fixed("cancel"),
772 ],
773 verb: Verb::Action,
774 rtype: "things",
775 nlabels: 2,
776 has_input: true,
777 errors: &[
778 "InvalidRequestException",
779 "InvalidStateTransitionException",
780 "ResourceNotFoundException",
781 "ServiceUnavailableException",
782 "ThrottlingException",
783 "VersionConflictException",
784 ],
785 rules: &[
786 Rule {
787 wire: "jobId",
788 src: Src::Label,
789 req: true,
790 kind: K::Str,
791 min_len: Some(1),
792 max_len: Some(64),
793 min_val: None,
794 max_val: None,
795 enums: &[],
796 },
797 Rule {
798 wire: "thingName",
799 src: Src::Label,
800 req: true,
801 kind: K::Str,
802 min_len: Some(1),
803 max_len: Some(128),
804 min_val: None,
805 max_val: None,
806 enums: &[],
807 },
808 ],
809 omembers: &[],
810 list_field: None,
811 list_elems: &[],
812 list_scalar: false,
813 req_payload: false,
814 },
815 OpMeta {
816 op: "ClearDefaultAuthorizer",
817 method: "DELETE",
818 segs: &[Seg::Fixed("default-authorizer")],
819 verb: Verb::Action,
820 rtype: "default-authorizer",
821 nlabels: 0,
822 has_input: true,
823 errors: &[
824 "InternalFailureException",
825 "InvalidRequestException",
826 "ResourceNotFoundException",
827 "ServiceUnavailableException",
828 "ThrottlingException",
829 "UnauthorizedException",
830 ],
831 rules: &[],
832 omembers: &[],
833 list_field: None,
834 list_elems: &[],
835 list_scalar: false,
836 req_payload: false,
837 },
838 OpMeta {
839 op: "ConfirmTopicRuleDestination",
840 method: "GET",
841 segs: &[
842 Seg::Fixed("confirmdestination"),
843 Seg::Greedy("confirmationToken"),
844 ],
845 verb: Verb::Action,
846 rtype: "confirmdestination",
847 nlabels: 1,
848 has_input: true,
849 errors: &[
850 "ConflictingResourceUpdateException",
851 "InternalException",
852 "InvalidRequestException",
853 "ServiceUnavailableException",
854 "UnauthorizedException",
855 ],
856 rules: &[Rule {
857 wire: "confirmationToken",
858 src: Src::Label,
859 req: true,
860 kind: K::Str,
861 min_len: Some(1),
862 max_len: Some(2048),
863 min_val: None,
864 max_val: None,
865 enums: &[],
866 }],
867 omembers: &[],
868 list_field: None,
869 list_elems: &[],
870 list_scalar: false,
871 req_payload: false,
872 },
873 OpMeta {
874 op: "CreateAuditSuppression",
875 method: "POST",
876 segs: &[
877 Seg::Fixed("audit"),
878 Seg::Fixed("suppressions"),
879 Seg::Fixed("create"),
880 ],
881 verb: Verb::Action,
882 rtype: "audit",
883 nlabels: 0,
884 has_input: true,
885 errors: &[
886 "InternalFailureException",
887 "InvalidRequestException",
888 "LimitExceededException",
889 "ResourceAlreadyExistsException",
890 "ThrottlingException",
891 ],
892 rules: &[
893 Rule {
894 wire: "checkName",
895 src: Src::Body,
896 req: true,
897 kind: K::Str,
898 min_len: None,
899 max_len: None,
900 min_val: None,
901 max_val: None,
902 enums: &[],
903 },
904 Rule {
905 wire: "resourceIdentifier",
906 src: Src::Body,
907 req: true,
908 kind: K::Struct,
909 min_len: None,
910 max_len: None,
911 min_val: None,
912 max_val: None,
913 enums: &[],
914 },
915 Rule {
916 wire: "description",
917 src: Src::Body,
918 req: false,
919 kind: K::Str,
920 min_len: Some(0),
921 max_len: Some(1000),
922 min_val: None,
923 max_val: None,
924 enums: &[],
925 },
926 Rule {
927 wire: "clientRequestToken",
928 src: Src::Body,
929 req: true,
930 kind: K::Str,
931 min_len: Some(1),
932 max_len: Some(64),
933 min_val: None,
934 max_val: None,
935 enums: &[],
936 },
937 ],
938 omembers: &[],
939 list_field: None,
940 list_elems: &[],
941 list_scalar: false,
942 req_payload: false,
943 },
944 OpMeta {
945 op: "CreateAuthorizer",
946 method: "POST",
947 segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
948 verb: Verb::Create,
949 rtype: "authorizer",
950 nlabels: 1,
951 has_input: true,
952 errors: &[
953 "InternalFailureException",
954 "InvalidRequestException",
955 "LimitExceededException",
956 "ResourceAlreadyExistsException",
957 "ServiceUnavailableException",
958 "ThrottlingException",
959 "UnauthorizedException",
960 ],
961 rules: &[
962 Rule {
963 wire: "authorizerName",
964 src: Src::Label,
965 req: true,
966 kind: K::Str,
967 min_len: Some(1),
968 max_len: Some(128),
969 min_val: None,
970 max_val: None,
971 enums: &[],
972 },
973 Rule {
974 wire: "authorizerFunctionArn",
975 src: Src::Body,
976 req: true,
977 kind: K::Str,
978 min_len: Some(0),
979 max_len: Some(2048),
980 min_val: None,
981 max_val: None,
982 enums: &[],
983 },
984 Rule {
985 wire: "tokenKeyName",
986 src: Src::Body,
987 req: false,
988 kind: K::Str,
989 min_len: Some(1),
990 max_len: Some(128),
991 min_val: None,
992 max_val: None,
993 enums: &[],
994 },
995 Rule {
996 wire: "status",
997 src: Src::Body,
998 req: false,
999 kind: K::Str,
1000 min_len: None,
1001 max_len: None,
1002 min_val: None,
1003 max_val: None,
1004 enums: &["ACTIVE", "INACTIVE"],
1005 },
1006 ],
1007 omembers: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
1008 list_field: None,
1009 list_elems: &[],
1010 list_scalar: false,
1011 req_payload: false,
1012 },
1013 OpMeta {
1014 op: "CreateBillingGroup",
1015 method: "POST",
1016 segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
1017 verb: Verb::Create,
1018 rtype: "billing-groups",
1019 nlabels: 1,
1020 has_input: true,
1021 errors: &[
1022 "InternalFailureException",
1023 "InvalidRequestException",
1024 "ResourceAlreadyExistsException",
1025 "ThrottlingException",
1026 ],
1027 rules: &[Rule {
1028 wire: "billingGroupName",
1029 src: Src::Label,
1030 req: true,
1031 kind: K::Str,
1032 min_len: Some(1),
1033 max_len: Some(128),
1034 min_val: None,
1035 max_val: None,
1036 enums: &[],
1037 }],
1038 omembers: &[
1039 ("billingGroupName", K::Str),
1040 ("billingGroupArn", K::Str),
1041 ("billingGroupId", K::Str),
1042 ],
1043 list_field: None,
1044 list_elems: &[],
1045 list_scalar: false,
1046 req_payload: false,
1047 },
1048 OpMeta {
1049 op: "CreateCertificateFromCsr",
1050 method: "POST",
1051 segs: &[Seg::Fixed("certificates")],
1052 verb: Verb::Action,
1053 rtype: "certificates",
1054 nlabels: 0,
1055 has_input: true,
1056 errors: &[
1057 "InternalFailureException",
1058 "InvalidRequestException",
1059 "ServiceUnavailableException",
1060 "ThrottlingException",
1061 "UnauthorizedException",
1062 ],
1063 rules: &[Rule {
1064 wire: "certificateSigningRequest",
1065 src: Src::Body,
1066 req: true,
1067 kind: K::Str,
1068 min_len: Some(1),
1069 max_len: Some(4096),
1070 min_val: None,
1071 max_val: None,
1072 enums: &[],
1073 }],
1074 omembers: &[
1075 ("certificateArn", K::Str),
1076 ("certificateId", K::Str),
1077 ("certificatePem", K::Str),
1078 ],
1079 list_field: None,
1080 list_elems: &[],
1081 list_scalar: false,
1082 req_payload: false,
1083 },
1084 OpMeta {
1085 op: "CreateCertificateProvider",
1086 method: "POST",
1087 segs: &[
1088 Seg::Fixed("certificate-providers"),
1089 Seg::Label("certificateProviderName"),
1090 ],
1091 verb: Verb::Create,
1092 rtype: "certificate-providers",
1093 nlabels: 1,
1094 has_input: true,
1095 errors: &[
1096 "InternalFailureException",
1097 "InvalidRequestException",
1098 "LimitExceededException",
1099 "ResourceAlreadyExistsException",
1100 "ServiceUnavailableException",
1101 "ThrottlingException",
1102 "UnauthorizedException",
1103 ],
1104 rules: &[
1105 Rule {
1106 wire: "certificateProviderName",
1107 src: Src::Label,
1108 req: true,
1109 kind: K::Str,
1110 min_len: Some(1),
1111 max_len: Some(128),
1112 min_val: None,
1113 max_val: None,
1114 enums: &[],
1115 },
1116 Rule {
1117 wire: "lambdaFunctionArn",
1118 src: Src::Body,
1119 req: true,
1120 kind: K::Str,
1121 min_len: Some(0),
1122 max_len: Some(2048),
1123 min_val: None,
1124 max_val: None,
1125 enums: &[],
1126 },
1127 Rule {
1128 wire: "accountDefaultForOperations",
1129 src: Src::Body,
1130 req: true,
1131 kind: K::List,
1132 min_len: Some(1),
1133 max_len: Some(1),
1134 min_val: None,
1135 max_val: None,
1136 enums: &[],
1137 },
1138 Rule {
1139 wire: "clientToken",
1140 src: Src::Body,
1141 req: false,
1142 kind: K::Str,
1143 min_len: Some(36),
1144 max_len: Some(64),
1145 min_val: None,
1146 max_val: None,
1147 enums: &[],
1148 },
1149 ],
1150 omembers: &[
1151 ("certificateProviderName", K::Str),
1152 ("certificateProviderArn", K::Str),
1153 ],
1154 list_field: None,
1155 list_elems: &[],
1156 list_scalar: false,
1157 req_payload: false,
1158 },
1159 OpMeta {
1160 op: "CreateCommand",
1161 method: "PUT",
1162 segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
1163 verb: Verb::Create,
1164 rtype: "commands",
1165 nlabels: 1,
1166 has_input: true,
1167 errors: &[
1168 "ConflictException",
1169 "InternalServerException",
1170 "ServiceQuotaExceededException",
1171 "ThrottlingException",
1172 "ValidationException",
1173 ],
1174 rules: &[
1175 Rule {
1176 wire: "commandId",
1177 src: Src::Label,
1178 req: true,
1179 kind: K::Str,
1180 min_len: Some(1),
1181 max_len: Some(64),
1182 min_val: None,
1183 max_val: None,
1184 enums: &[],
1185 },
1186 Rule {
1187 wire: "namespace",
1188 src: Src::Body,
1189 req: false,
1190 kind: K::Str,
1191 min_len: None,
1192 max_len: None,
1193 min_val: None,
1194 max_val: None,
1195 enums: &["AWS-IoT", "AWS-IoT-FleetWise"],
1196 },
1197 Rule {
1198 wire: "displayName",
1199 src: Src::Body,
1200 req: false,
1201 kind: K::Str,
1202 min_len: Some(0),
1203 max_len: Some(64),
1204 min_val: None,
1205 max_val: None,
1206 enums: &[],
1207 },
1208 Rule {
1209 wire: "description",
1210 src: Src::Body,
1211 req: false,
1212 kind: K::Str,
1213 min_len: Some(0),
1214 max_len: Some(2028),
1215 min_val: None,
1216 max_val: None,
1217 enums: &[],
1218 },
1219 Rule {
1220 wire: "payloadTemplate",
1221 src: Src::Body,
1222 req: false,
1223 kind: K::Str,
1224 min_len: Some(0),
1225 max_len: Some(32768),
1226 min_val: None,
1227 max_val: None,
1228 enums: &[],
1229 },
1230 Rule {
1231 wire: "mandatoryParameters",
1232 src: Src::Body,
1233 req: false,
1234 kind: K::List,
1235 min_len: Some(1),
1236 max_len: None,
1237 min_val: None,
1238 max_val: None,
1239 enums: &[],
1240 },
1241 Rule {
1242 wire: "roleArn",
1243 src: Src::Body,
1244 req: false,
1245 kind: K::Str,
1246 min_len: Some(20),
1247 max_len: Some(2048),
1248 min_val: None,
1249 max_val: None,
1250 enums: &[],
1251 },
1252 ],
1253 omembers: &[("commandId", K::Str), ("commandArn", K::Str)],
1254 list_field: None,
1255 list_elems: &[],
1256 list_scalar: false,
1257 req_payload: false,
1258 },
1259 OpMeta {
1260 op: "CreateCustomMetric",
1261 method: "POST",
1262 segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
1263 verb: Verb::Create,
1264 rtype: "custom-metric",
1265 nlabels: 1,
1266 has_input: true,
1267 errors: &[
1268 "InternalFailureException",
1269 "InvalidRequestException",
1270 "LimitExceededException",
1271 "ResourceAlreadyExistsException",
1272 "ThrottlingException",
1273 ],
1274 rules: &[
1275 Rule {
1276 wire: "metricName",
1277 src: Src::Label,
1278 req: true,
1279 kind: K::Str,
1280 min_len: Some(1),
1281 max_len: Some(128),
1282 min_val: None,
1283 max_val: None,
1284 enums: &[],
1285 },
1286 Rule {
1287 wire: "displayName",
1288 src: Src::Body,
1289 req: false,
1290 kind: K::Str,
1291 min_len: Some(0),
1292 max_len: Some(128),
1293 min_val: None,
1294 max_val: None,
1295 enums: &[],
1296 },
1297 Rule {
1298 wire: "metricType",
1299 src: Src::Body,
1300 req: true,
1301 kind: K::Str,
1302 min_len: None,
1303 max_len: None,
1304 min_val: None,
1305 max_val: None,
1306 enums: &["string-list", "ip-address-list", "number-list", "number"],
1307 },
1308 Rule {
1309 wire: "clientRequestToken",
1310 src: Src::Body,
1311 req: true,
1312 kind: K::Str,
1313 min_len: Some(1),
1314 max_len: Some(64),
1315 min_val: None,
1316 max_val: None,
1317 enums: &[],
1318 },
1319 ],
1320 omembers: &[("metricName", K::Str), ("metricArn", K::Str)],
1321 list_field: None,
1322 list_elems: &[],
1323 list_scalar: false,
1324 req_payload: false,
1325 },
1326 OpMeta {
1327 op: "CreateDimension",
1328 method: "POST",
1329 segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
1330 verb: Verb::Create,
1331 rtype: "dimensions",
1332 nlabels: 1,
1333 has_input: true,
1334 errors: &[
1335 "InternalFailureException",
1336 "InvalidRequestException",
1337 "LimitExceededException",
1338 "ResourceAlreadyExistsException",
1339 "ThrottlingException",
1340 ],
1341 rules: &[
1342 Rule {
1343 wire: "name",
1344 src: Src::Label,
1345 req: true,
1346 kind: K::Str,
1347 min_len: Some(1),
1348 max_len: Some(128),
1349 min_val: None,
1350 max_val: None,
1351 enums: &[],
1352 },
1353 Rule {
1354 wire: "type",
1355 src: Src::Body,
1356 req: true,
1357 kind: K::Str,
1358 min_len: None,
1359 max_len: None,
1360 min_val: None,
1361 max_val: None,
1362 enums: &["TOPIC_FILTER"],
1363 },
1364 Rule {
1365 wire: "stringValues",
1366 src: Src::Body,
1367 req: true,
1368 kind: K::List,
1369 min_len: Some(1),
1370 max_len: Some(100),
1371 min_val: None,
1372 max_val: None,
1373 enums: &[],
1374 },
1375 Rule {
1376 wire: "clientRequestToken",
1377 src: Src::Body,
1378 req: true,
1379 kind: K::Str,
1380 min_len: Some(1),
1381 max_len: Some(64),
1382 min_val: None,
1383 max_val: None,
1384 enums: &[],
1385 },
1386 ],
1387 omembers: &[("name", K::Str), ("arn", K::Str)],
1388 list_field: None,
1389 list_elems: &[],
1390 list_scalar: false,
1391 req_payload: false,
1392 },
1393 OpMeta {
1394 op: "CreateDomainConfiguration",
1395 method: "POST",
1396 segs: &[
1397 Seg::Fixed("domainConfigurations"),
1398 Seg::Label("domainConfigurationName"),
1399 ],
1400 verb: Verb::Create,
1401 rtype: "domainConfigurations",
1402 nlabels: 1,
1403 has_input: true,
1404 errors: &[
1405 "CertificateValidationException",
1406 "InternalFailureException",
1407 "InvalidRequestException",
1408 "LimitExceededException",
1409 "ResourceAlreadyExistsException",
1410 "ServiceUnavailableException",
1411 "ThrottlingException",
1412 "UnauthorizedException",
1413 ],
1414 rules: &[
1415 Rule {
1416 wire: "domainConfigurationName",
1417 src: Src::Label,
1418 req: true,
1419 kind: K::Str,
1420 min_len: Some(1),
1421 max_len: Some(128),
1422 min_val: None,
1423 max_val: None,
1424 enums: &[],
1425 },
1426 Rule {
1427 wire: "domainName",
1428 src: Src::Body,
1429 req: false,
1430 kind: K::Str,
1431 min_len: Some(1),
1432 max_len: Some(253),
1433 min_val: None,
1434 max_val: None,
1435 enums: &[],
1436 },
1437 Rule {
1438 wire: "serverCertificateArns",
1439 src: Src::Body,
1440 req: false,
1441 kind: K::List,
1442 min_len: Some(0),
1443 max_len: Some(1),
1444 min_val: None,
1445 max_val: None,
1446 enums: &[],
1447 },
1448 Rule {
1449 wire: "validationCertificateArn",
1450 src: Src::Body,
1451 req: false,
1452 kind: K::Str,
1453 min_len: Some(1),
1454 max_len: Some(2048),
1455 min_val: None,
1456 max_val: None,
1457 enums: &[],
1458 },
1459 Rule {
1460 wire: "serviceType",
1461 src: Src::Body,
1462 req: false,
1463 kind: K::Str,
1464 min_len: None,
1465 max_len: None,
1466 min_val: None,
1467 max_val: None,
1468 enums: &["DATA", "CREDENTIAL_PROVIDER", "JOBS"],
1469 },
1470 Rule {
1471 wire: "authenticationType",
1472 src: Src::Body,
1473 req: false,
1474 kind: K::Str,
1475 min_len: None,
1476 max_len: None,
1477 min_val: None,
1478 max_val: None,
1479 enums: &[
1480 "CUSTOM_AUTH_X509",
1481 "CUSTOM_AUTH",
1482 "AWS_X509",
1483 "AWS_SIGV4",
1484 "DEFAULT",
1485 ],
1486 },
1487 Rule {
1488 wire: "applicationProtocol",
1489 src: Src::Body,
1490 req: false,
1491 kind: K::Str,
1492 min_len: None,
1493 max_len: None,
1494 min_val: None,
1495 max_val: None,
1496 enums: &["SECURE_MQTT", "MQTT_WSS", "HTTPS", "DEFAULT"],
1497 },
1498 ],
1499 omembers: &[
1500 ("domainConfigurationName", K::Str),
1501 ("domainConfigurationArn", K::Str),
1502 ],
1503 list_field: None,
1504 list_elems: &[],
1505 list_scalar: false,
1506 req_payload: false,
1507 },
1508 OpMeta {
1509 op: "CreateDynamicThingGroup",
1510 method: "POST",
1511 segs: &[
1512 Seg::Fixed("dynamic-thing-groups"),
1513 Seg::Label("thingGroupName"),
1514 ],
1515 verb: Verb::Create,
1516 rtype: "dynamic-thing-groups",
1517 nlabels: 1,
1518 has_input: true,
1519 errors: &[
1520 "InternalFailureException",
1521 "InvalidQueryException",
1522 "InvalidRequestException",
1523 "LimitExceededException",
1524 "ResourceAlreadyExistsException",
1525 "ResourceNotFoundException",
1526 "ThrottlingException",
1527 ],
1528 rules: &[
1529 Rule {
1530 wire: "thingGroupName",
1531 src: Src::Label,
1532 req: true,
1533 kind: K::Str,
1534 min_len: Some(1),
1535 max_len: Some(128),
1536 min_val: None,
1537 max_val: None,
1538 enums: &[],
1539 },
1540 Rule {
1541 wire: "indexName",
1542 src: Src::Body,
1543 req: false,
1544 kind: K::Str,
1545 min_len: Some(1),
1546 max_len: Some(128),
1547 min_val: None,
1548 max_val: None,
1549 enums: &[],
1550 },
1551 Rule {
1552 wire: "queryString",
1553 src: Src::Body,
1554 req: true,
1555 kind: K::Str,
1556 min_len: Some(1),
1557 max_len: None,
1558 min_val: None,
1559 max_val: None,
1560 enums: &[],
1561 },
1562 ],
1563 omembers: &[
1564 ("thingGroupName", K::Str),
1565 ("thingGroupArn", K::Str),
1566 ("thingGroupId", K::Str),
1567 ("indexName", K::Str),
1568 ("queryString", K::Str),
1569 ("queryVersion", K::Str),
1570 ],
1571 list_field: None,
1572 list_elems: &[],
1573 list_scalar: false,
1574 req_payload: false,
1575 },
1576 OpMeta {
1577 op: "CreateFleetMetric",
1578 method: "PUT",
1579 segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
1580 verb: Verb::Create,
1581 rtype: "fleet-metric",
1582 nlabels: 1,
1583 has_input: true,
1584 errors: &[
1585 "IndexNotReadyException",
1586 "InternalFailureException",
1587 "InvalidAggregationException",
1588 "InvalidQueryException",
1589 "InvalidRequestException",
1590 "LimitExceededException",
1591 "ResourceAlreadyExistsException",
1592 "ResourceNotFoundException",
1593 "ServiceUnavailableException",
1594 "ThrottlingException",
1595 "UnauthorizedException",
1596 ],
1597 rules: &[
1598 Rule {
1599 wire: "metricName",
1600 src: Src::Label,
1601 req: true,
1602 kind: K::Str,
1603 min_len: Some(1),
1604 max_len: Some(128),
1605 min_val: None,
1606 max_val: None,
1607 enums: &[],
1608 },
1609 Rule {
1610 wire: "queryString",
1611 src: Src::Body,
1612 req: true,
1613 kind: K::Str,
1614 min_len: Some(1),
1615 max_len: None,
1616 min_val: None,
1617 max_val: None,
1618 enums: &[],
1619 },
1620 Rule {
1621 wire: "aggregationType",
1622 src: Src::Body,
1623 req: true,
1624 kind: K::Struct,
1625 min_len: None,
1626 max_len: None,
1627 min_val: None,
1628 max_val: None,
1629 enums: &[],
1630 },
1631 Rule {
1632 wire: "period",
1633 src: Src::Body,
1634 req: true,
1635 kind: K::Int,
1636 min_len: None,
1637 max_len: None,
1638 min_val: Some(60),
1639 max_val: Some(86400),
1640 enums: &[],
1641 },
1642 Rule {
1643 wire: "aggregationField",
1644 src: Src::Body,
1645 req: true,
1646 kind: K::Str,
1647 min_len: Some(1),
1648 max_len: None,
1649 min_val: None,
1650 max_val: None,
1651 enums: &[],
1652 },
1653 Rule {
1654 wire: "description",
1655 src: Src::Body,
1656 req: false,
1657 kind: K::Str,
1658 min_len: Some(0),
1659 max_len: Some(1024),
1660 min_val: None,
1661 max_val: None,
1662 enums: &[],
1663 },
1664 Rule {
1665 wire: "indexName",
1666 src: Src::Body,
1667 req: false,
1668 kind: K::Str,
1669 min_len: Some(1),
1670 max_len: Some(128),
1671 min_val: None,
1672 max_val: None,
1673 enums: &[],
1674 },
1675 Rule {
1676 wire: "unit",
1677 src: Src::Body,
1678 req: false,
1679 kind: K::Str,
1680 min_len: None,
1681 max_len: None,
1682 min_val: None,
1683 max_val: None,
1684 enums: &[
1685 "Seconds",
1686 "Microseconds",
1687 "Milliseconds",
1688 "Bytes",
1689 "Kilobytes",
1690 "Megabytes",
1691 "Gigabytes",
1692 "Terabytes",
1693 "Bits",
1694 "Kilobits",
1695 "Megabits",
1696 "Gigabits",
1697 "Terabits",
1698 "Percent",
1699 "Count",
1700 "Bytes/Second",
1701 "Kilobytes/Second",
1702 "Megabytes/Second",
1703 "Gigabytes/Second",
1704 "Terabytes/Second",
1705 "Bits/Second",
1706 "Kilobits/Second",
1707 "Megabits/Second",
1708 "Gigabits/Second",
1709 "Terabits/Second",
1710 "Count/Second",
1711 "None",
1712 ],
1713 },
1714 ],
1715 omembers: &[("metricName", K::Str), ("metricArn", K::Str)],
1716 list_field: None,
1717 list_elems: &[],
1718 list_scalar: false,
1719 req_payload: false,
1720 },
1721 OpMeta {
1722 op: "CreateJob",
1723 method: "PUT",
1724 segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
1725 verb: Verb::Create,
1726 rtype: "jobs",
1727 nlabels: 1,
1728 has_input: true,
1729 errors: &[
1730 "InvalidRequestException",
1731 "LimitExceededException",
1732 "ResourceAlreadyExistsException",
1733 "ResourceNotFoundException",
1734 "ServiceUnavailableException",
1735 "ThrottlingException",
1736 ],
1737 rules: &[
1738 Rule {
1739 wire: "jobId",
1740 src: Src::Label,
1741 req: true,
1742 kind: K::Str,
1743 min_len: Some(1),
1744 max_len: Some(64),
1745 min_val: None,
1746 max_val: None,
1747 enums: &[],
1748 },
1749 Rule {
1750 wire: "targets",
1751 src: Src::Body,
1752 req: true,
1753 kind: K::List,
1754 min_len: Some(1),
1755 max_len: None,
1756 min_val: None,
1757 max_val: None,
1758 enums: &[],
1759 },
1760 Rule {
1761 wire: "documentSource",
1762 src: Src::Body,
1763 req: false,
1764 kind: K::Str,
1765 min_len: Some(1),
1766 max_len: Some(1350),
1767 min_val: None,
1768 max_val: None,
1769 enums: &[],
1770 },
1771 Rule {
1772 wire: "document",
1773 src: Src::Body,
1774 req: false,
1775 kind: K::Str,
1776 min_len: Some(0),
1777 max_len: Some(32768),
1778 min_val: None,
1779 max_val: None,
1780 enums: &[],
1781 },
1782 Rule {
1783 wire: "description",
1784 src: Src::Body,
1785 req: false,
1786 kind: K::Str,
1787 min_len: Some(0),
1788 max_len: Some(2028),
1789 min_val: None,
1790 max_val: None,
1791 enums: &[],
1792 },
1793 Rule {
1794 wire: "targetSelection",
1795 src: Src::Body,
1796 req: false,
1797 kind: K::Str,
1798 min_len: None,
1799 max_len: None,
1800 min_val: None,
1801 max_val: None,
1802 enums: &["CONTINUOUS", "SNAPSHOT"],
1803 },
1804 Rule {
1805 wire: "jobTemplateArn",
1806 src: Src::Body,
1807 req: false,
1808 kind: K::Str,
1809 min_len: Some(1),
1810 max_len: Some(1600),
1811 min_val: None,
1812 max_val: None,
1813 enums: &[],
1814 },
1815 ],
1816 omembers: &[
1817 ("jobArn", K::Str),
1818 ("jobId", K::Str),
1819 ("description", K::Str),
1820 ],
1821 list_field: None,
1822 list_elems: &[],
1823 list_scalar: false,
1824 req_payload: false,
1825 },
1826 OpMeta {
1827 op: "CreateJobTemplate",
1828 method: "PUT",
1829 segs: &[Seg::Fixed("job-templates"), Seg::Label("jobTemplateId")],
1830 verb: Verb::Create,
1831 rtype: "job-templates",
1832 nlabels: 1,
1833 has_input: true,
1834 errors: &[
1835 "ConflictException",
1836 "InternalFailureException",
1837 "InvalidRequestException",
1838 "LimitExceededException",
1839 "ResourceNotFoundException",
1840 "ThrottlingException",
1841 ],
1842 rules: &[
1843 Rule {
1844 wire: "jobTemplateId",
1845 src: Src::Label,
1846 req: true,
1847 kind: K::Str,
1848 min_len: Some(1),
1849 max_len: Some(64),
1850 min_val: None,
1851 max_val: None,
1852 enums: &[],
1853 },
1854 Rule {
1855 wire: "documentSource",
1856 src: Src::Body,
1857 req: false,
1858 kind: K::Str,
1859 min_len: Some(1),
1860 max_len: Some(1350),
1861 min_val: None,
1862 max_val: None,
1863 enums: &[],
1864 },
1865 Rule {
1866 wire: "document",
1867 src: Src::Body,
1868 req: false,
1869 kind: K::Str,
1870 min_len: Some(0),
1871 max_len: Some(32768),
1872 min_val: None,
1873 max_val: None,
1874 enums: &[],
1875 },
1876 Rule {
1877 wire: "description",
1878 src: Src::Body,
1879 req: true,
1880 kind: K::Str,
1881 min_len: Some(0),
1882 max_len: Some(2028),
1883 min_val: None,
1884 max_val: None,
1885 enums: &[],
1886 },
1887 ],
1888 omembers: &[("jobTemplateArn", K::Str), ("jobTemplateId", K::Str)],
1889 list_field: None,
1890 list_elems: &[],
1891 list_scalar: false,
1892 req_payload: false,
1893 },
1894 OpMeta {
1895 op: "CreateKeysAndCertificate",
1896 method: "POST",
1897 segs: &[Seg::Fixed("keys-and-certificate")],
1898 verb: Verb::Action,
1899 rtype: "keys-and-certificate",
1900 nlabels: 0,
1901 has_input: true,
1902 errors: &[
1903 "InternalFailureException",
1904 "InvalidRequestException",
1905 "ServiceUnavailableException",
1906 "ThrottlingException",
1907 "UnauthorizedException",
1908 ],
1909 rules: &[],
1910 omembers: &[
1911 ("certificateArn", K::Str),
1912 ("certificateId", K::Str),
1913 ("certificatePem", K::Str),
1914 ("keyPair", K::Struct),
1915 ],
1916 list_field: None,
1917 list_elems: &[],
1918 list_scalar: false,
1919 req_payload: false,
1920 },
1921 OpMeta {
1922 op: "CreateMitigationAction",
1923 method: "POST",
1924 segs: &[
1925 Seg::Fixed("mitigationactions"),
1926 Seg::Fixed("actions"),
1927 Seg::Label("actionName"),
1928 ],
1929 verb: Verb::Create,
1930 rtype: "mitigationactions",
1931 nlabels: 1,
1932 has_input: true,
1933 errors: &[
1934 "InternalFailureException",
1935 "InvalidRequestException",
1936 "LimitExceededException",
1937 "ResourceAlreadyExistsException",
1938 "ThrottlingException",
1939 ],
1940 rules: &[
1941 Rule {
1942 wire: "actionName",
1943 src: Src::Label,
1944 req: true,
1945 kind: K::Str,
1946 min_len: Some(0),
1947 max_len: Some(128),
1948 min_val: None,
1949 max_val: None,
1950 enums: &[],
1951 },
1952 Rule {
1953 wire: "roleArn",
1954 src: Src::Body,
1955 req: true,
1956 kind: K::Str,
1957 min_len: Some(20),
1958 max_len: Some(2048),
1959 min_val: None,
1960 max_val: None,
1961 enums: &[],
1962 },
1963 Rule {
1964 wire: "actionParams",
1965 src: Src::Body,
1966 req: true,
1967 kind: K::Struct,
1968 min_len: None,
1969 max_len: None,
1970 min_val: None,
1971 max_val: None,
1972 enums: &[],
1973 },
1974 ],
1975 omembers: &[("actionArn", K::Str), ("actionId", K::Str)],
1976 list_field: None,
1977 list_elems: &[],
1978 list_scalar: false,
1979 req_payload: false,
1980 },
1981 OpMeta {
1982 op: "CreateOTAUpdate",
1983 method: "POST",
1984 segs: &[Seg::Fixed("otaUpdates"), Seg::Label("otaUpdateId")],
1985 verb: Verb::Create,
1986 rtype: "otaUpdates",
1987 nlabels: 1,
1988 has_input: true,
1989 errors: &[
1990 "InternalFailureException",
1991 "InvalidRequestException",
1992 "LimitExceededException",
1993 "ResourceAlreadyExistsException",
1994 "ResourceNotFoundException",
1995 "ServiceUnavailableException",
1996 "ThrottlingException",
1997 "UnauthorizedException",
1998 ],
1999 rules: &[
2000 Rule {
2001 wire: "otaUpdateId",
2002 src: Src::Label,
2003 req: true,
2004 kind: K::Str,
2005 min_len: Some(1),
2006 max_len: Some(128),
2007 min_val: None,
2008 max_val: None,
2009 enums: &[],
2010 },
2011 Rule {
2012 wire: "description",
2013 src: Src::Body,
2014 req: false,
2015 kind: K::Str,
2016 min_len: Some(0),
2017 max_len: Some(2028),
2018 min_val: None,
2019 max_val: None,
2020 enums: &[],
2021 },
2022 Rule {
2023 wire: "targets",
2024 src: Src::Body,
2025 req: true,
2026 kind: K::List,
2027 min_len: Some(1),
2028 max_len: None,
2029 min_val: None,
2030 max_val: None,
2031 enums: &[],
2032 },
2033 Rule {
2034 wire: "protocols",
2035 src: Src::Body,
2036 req: false,
2037 kind: K::List,
2038 min_len: Some(1),
2039 max_len: Some(2),
2040 min_val: None,
2041 max_val: None,
2042 enums: &[],
2043 },
2044 Rule {
2045 wire: "targetSelection",
2046 src: Src::Body,
2047 req: false,
2048 kind: K::Str,
2049 min_len: None,
2050 max_len: None,
2051 min_val: None,
2052 max_val: None,
2053 enums: &["CONTINUOUS", "SNAPSHOT"],
2054 },
2055 Rule {
2056 wire: "files",
2057 src: Src::Body,
2058 req: true,
2059 kind: K::List,
2060 min_len: Some(1),
2061 max_len: None,
2062 min_val: None,
2063 max_val: None,
2064 enums: &[],
2065 },
2066 Rule {
2067 wire: "roleArn",
2068 src: Src::Body,
2069 req: true,
2070 kind: K::Str,
2071 min_len: Some(20),
2072 max_len: Some(2048),
2073 min_val: None,
2074 max_val: None,
2075 enums: &[],
2076 },
2077 ],
2078 omembers: &[
2079 ("otaUpdateId", K::Str),
2080 ("awsIotJobId", K::Str),
2081 ("otaUpdateArn", K::Str),
2082 ("awsIotJobArn", K::Str),
2083 ("otaUpdateStatus", K::Str),
2084 ],
2085 list_field: None,
2086 list_elems: &[],
2087 list_scalar: false,
2088 req_payload: false,
2089 },
2090 OpMeta {
2091 op: "CreatePackage",
2092 method: "PUT",
2093 segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
2094 verb: Verb::Create,
2095 rtype: "packages",
2096 nlabels: 1,
2097 has_input: true,
2098 errors: &[
2099 "ConflictException",
2100 "InternalServerException",
2101 "ServiceQuotaExceededException",
2102 "ThrottlingException",
2103 "ValidationException",
2104 ],
2105 rules: &[
2106 Rule {
2107 wire: "packageName",
2108 src: Src::Label,
2109 req: true,
2110 kind: K::Str,
2111 min_len: Some(1),
2112 max_len: Some(128),
2113 min_val: None,
2114 max_val: None,
2115 enums: &[],
2116 },
2117 Rule {
2118 wire: "description",
2119 src: Src::Body,
2120 req: false,
2121 kind: K::Str,
2122 min_len: Some(0),
2123 max_len: Some(1024),
2124 min_val: None,
2125 max_val: None,
2126 enums: &[],
2127 },
2128 Rule {
2129 wire: "tags",
2130 src: Src::Body,
2131 req: false,
2132 kind: K::Map,
2133 min_len: Some(1),
2134 max_len: Some(50),
2135 min_val: None,
2136 max_val: None,
2137 enums: &[],
2138 },
2139 Rule {
2140 wire: "clientToken",
2141 src: Src::Query,
2142 req: false,
2143 kind: K::Str,
2144 min_len: Some(36),
2145 max_len: Some(64),
2146 min_val: None,
2147 max_val: None,
2148 enums: &[],
2149 },
2150 ],
2151 omembers: &[
2152 ("packageName", K::Str),
2153 ("packageArn", K::Str),
2154 ("description", K::Str),
2155 ],
2156 list_field: None,
2157 list_elems: &[],
2158 list_scalar: false,
2159 req_payload: false,
2160 },
2161 OpMeta {
2162 op: "CreatePackageVersion",
2163 method: "PUT",
2164 segs: &[
2165 Seg::Fixed("packages"),
2166 Seg::Label("packageName"),
2167 Seg::Fixed("versions"),
2168 Seg::Label("versionName"),
2169 ],
2170 verb: Verb::Create,
2171 rtype: "packages",
2172 nlabels: 2,
2173 has_input: true,
2174 errors: &[
2175 "ConflictException",
2176 "InternalServerException",
2177 "ServiceQuotaExceededException",
2178 "ThrottlingException",
2179 "ValidationException",
2180 ],
2181 rules: &[
2182 Rule {
2183 wire: "packageName",
2184 src: Src::Label,
2185 req: true,
2186 kind: K::Str,
2187 min_len: Some(1),
2188 max_len: Some(128),
2189 min_val: None,
2190 max_val: None,
2191 enums: &[],
2192 },
2193 Rule {
2194 wire: "versionName",
2195 src: Src::Label,
2196 req: true,
2197 kind: K::Str,
2198 min_len: Some(1),
2199 max_len: Some(64),
2200 min_val: None,
2201 max_val: None,
2202 enums: &[],
2203 },
2204 Rule {
2205 wire: "description",
2206 src: Src::Body,
2207 req: false,
2208 kind: K::Str,
2209 min_len: Some(0),
2210 max_len: Some(1024),
2211 min_val: None,
2212 max_val: None,
2213 enums: &[],
2214 },
2215 Rule {
2216 wire: "recipe",
2217 src: Src::Body,
2218 req: false,
2219 kind: K::Str,
2220 min_len: Some(0),
2221 max_len: Some(3072),
2222 min_val: None,
2223 max_val: None,
2224 enums: &[],
2225 },
2226 Rule {
2227 wire: "tags",
2228 src: Src::Body,
2229 req: false,
2230 kind: K::Map,
2231 min_len: Some(1),
2232 max_len: Some(50),
2233 min_val: None,
2234 max_val: None,
2235 enums: &[],
2236 },
2237 Rule {
2238 wire: "clientToken",
2239 src: Src::Query,
2240 req: false,
2241 kind: K::Str,
2242 min_len: Some(36),
2243 max_len: Some(64),
2244 min_val: None,
2245 max_val: None,
2246 enums: &[],
2247 },
2248 ],
2249 omembers: &[
2250 ("packageVersionArn", K::Str),
2251 ("packageName", K::Str),
2252 ("versionName", K::Str),
2253 ("description", K::Str),
2254 ("attributes", K::Map),
2255 ("status", K::Str),
2256 ("errorReason", K::Str),
2257 ],
2258 list_field: None,
2259 list_elems: &[],
2260 list_scalar: false,
2261 req_payload: false,
2262 },
2263 OpMeta {
2264 op: "CreatePolicy",
2265 method: "POST",
2266 segs: &[Seg::Fixed("policies"), Seg::Label("policyName")],
2267 verb: Verb::Create,
2268 rtype: "policies",
2269 nlabels: 1,
2270 has_input: true,
2271 errors: &[
2272 "InternalFailureException",
2273 "InvalidRequestException",
2274 "MalformedPolicyException",
2275 "ResourceAlreadyExistsException",
2276 "ServiceUnavailableException",
2277 "ThrottlingException",
2278 "UnauthorizedException",
2279 ],
2280 rules: &[
2281 Rule {
2282 wire: "policyName",
2283 src: Src::Label,
2284 req: true,
2285 kind: K::Str,
2286 min_len: Some(1),
2287 max_len: Some(128),
2288 min_val: None,
2289 max_val: None,
2290 enums: &[],
2291 },
2292 Rule {
2293 wire: "policyDocument",
2294 src: Src::Body,
2295 req: true,
2296 kind: K::Str,
2297 min_len: Some(0),
2298 max_len: Some(404600),
2299 min_val: None,
2300 max_val: None,
2301 enums: &[],
2302 },
2303 ],
2304 omembers: &[
2305 ("policyName", K::Str),
2306 ("policyArn", K::Str),
2307 ("policyDocument", K::Str),
2308 ("policyVersionId", K::Str),
2309 ],
2310 list_field: None,
2311 list_elems: &[],
2312 list_scalar: false,
2313 req_payload: false,
2314 },
2315 OpMeta {
2316 op: "CreatePolicyVersion",
2317 method: "POST",
2318 segs: &[
2319 Seg::Fixed("policies"),
2320 Seg::Label("policyName"),
2321 Seg::Fixed("version"),
2322 ],
2323 verb: Verb::Action,
2324 rtype: "policies",
2325 nlabels: 1,
2326 has_input: true,
2327 errors: &[
2328 "InternalFailureException",
2329 "InvalidRequestException",
2330 "MalformedPolicyException",
2331 "ResourceNotFoundException",
2332 "ServiceUnavailableException",
2333 "ThrottlingException",
2334 "UnauthorizedException",
2335 "VersionsLimitExceededException",
2336 ],
2337 rules: &[
2338 Rule {
2339 wire: "policyName",
2340 src: Src::Label,
2341 req: true,
2342 kind: K::Str,
2343 min_len: Some(1),
2344 max_len: Some(128),
2345 min_val: None,
2346 max_val: None,
2347 enums: &[],
2348 },
2349 Rule {
2350 wire: "policyDocument",
2351 src: Src::Body,
2352 req: true,
2353 kind: K::Str,
2354 min_len: Some(0),
2355 max_len: Some(404600),
2356 min_val: None,
2357 max_val: None,
2358 enums: &[],
2359 },
2360 ],
2361 omembers: &[
2362 ("policyArn", K::Str),
2363 ("policyDocument", K::Str),
2364 ("policyVersionId", K::Str),
2365 ("isDefaultVersion", K::Bool),
2366 ],
2367 list_field: None,
2368 list_elems: &[],
2369 list_scalar: false,
2370 req_payload: false,
2371 },
2372 OpMeta {
2373 op: "CreateProvisioningClaim",
2374 method: "POST",
2375 segs: &[
2376 Seg::Fixed("provisioning-templates"),
2377 Seg::Label("templateName"),
2378 Seg::Fixed("provisioning-claim"),
2379 ],
2380 verb: Verb::Action,
2381 rtype: "provisioning-templates",
2382 nlabels: 1,
2383 has_input: true,
2384 errors: &[
2385 "InternalFailureException",
2386 "InvalidRequestException",
2387 "ResourceNotFoundException",
2388 "ServiceUnavailableException",
2389 "ThrottlingException",
2390 "UnauthorizedException",
2391 ],
2392 rules: &[Rule {
2393 wire: "templateName",
2394 src: Src::Label,
2395 req: true,
2396 kind: K::Str,
2397 min_len: Some(1),
2398 max_len: Some(36),
2399 min_val: None,
2400 max_val: None,
2401 enums: &[],
2402 }],
2403 omembers: &[
2404 ("certificateId", K::Str),
2405 ("certificatePem", K::Str),
2406 ("keyPair", K::Struct),
2407 ("expiration", K::Ts),
2408 ],
2409 list_field: None,
2410 list_elems: &[],
2411 list_scalar: false,
2412 req_payload: false,
2413 },
2414 OpMeta {
2415 op: "CreateProvisioningTemplate",
2416 method: "POST",
2417 segs: &[Seg::Fixed("provisioning-templates")],
2418 verb: Verb::Action,
2419 rtype: "provisioning-templates",
2420 nlabels: 0,
2421 has_input: true,
2422 errors: &[
2423 "InternalFailureException",
2424 "InvalidRequestException",
2425 "LimitExceededException",
2426 "ResourceAlreadyExistsException",
2427 "ThrottlingException",
2428 "UnauthorizedException",
2429 ],
2430 rules: &[
2431 Rule {
2432 wire: "templateName",
2433 src: Src::Body,
2434 req: true,
2435 kind: K::Str,
2436 min_len: Some(1),
2437 max_len: Some(36),
2438 min_val: None,
2439 max_val: None,
2440 enums: &[],
2441 },
2442 Rule {
2443 wire: "description",
2444 src: Src::Body,
2445 req: false,
2446 kind: K::Str,
2447 min_len: Some(0),
2448 max_len: Some(500),
2449 min_val: None,
2450 max_val: None,
2451 enums: &[],
2452 },
2453 Rule {
2454 wire: "templateBody",
2455 src: Src::Body,
2456 req: true,
2457 kind: K::Str,
2458 min_len: Some(0),
2459 max_len: Some(10240),
2460 min_val: None,
2461 max_val: None,
2462 enums: &[],
2463 },
2464 Rule {
2465 wire: "provisioningRoleArn",
2466 src: Src::Body,
2467 req: true,
2468 kind: K::Str,
2469 min_len: Some(20),
2470 max_len: Some(2048),
2471 min_val: None,
2472 max_val: None,
2473 enums: &[],
2474 },
2475 Rule {
2476 wire: "type",
2477 src: Src::Body,
2478 req: false,
2479 kind: K::Str,
2480 min_len: None,
2481 max_len: None,
2482 min_val: None,
2483 max_val: None,
2484 enums: &["FLEET_PROVISIONING", "JITP"],
2485 },
2486 ],
2487 omembers: &[
2488 ("templateArn", K::Str),
2489 ("templateName", K::Str),
2490 ("defaultVersionId", K::Int),
2491 ],
2492 list_field: None,
2493 list_elems: &[],
2494 list_scalar: false,
2495 req_payload: false,
2496 },
2497 OpMeta {
2498 op: "CreateProvisioningTemplateVersion",
2499 method: "POST",
2500 segs: &[
2501 Seg::Fixed("provisioning-templates"),
2502 Seg::Label("templateName"),
2503 Seg::Fixed("versions"),
2504 ],
2505 verb: Verb::Action,
2506 rtype: "provisioning-templates",
2507 nlabels: 1,
2508 has_input: true,
2509 errors: &[
2510 "ConflictingResourceUpdateException",
2511 "InternalFailureException",
2512 "InvalidRequestException",
2513 "ResourceNotFoundException",
2514 "ThrottlingException",
2515 "UnauthorizedException",
2516 "VersionsLimitExceededException",
2517 ],
2518 rules: &[
2519 Rule {
2520 wire: "templateName",
2521 src: Src::Label,
2522 req: true,
2523 kind: K::Str,
2524 min_len: Some(1),
2525 max_len: Some(36),
2526 min_val: None,
2527 max_val: None,
2528 enums: &[],
2529 },
2530 Rule {
2531 wire: "templateBody",
2532 src: Src::Body,
2533 req: true,
2534 kind: K::Str,
2535 min_len: Some(0),
2536 max_len: Some(10240),
2537 min_val: None,
2538 max_val: None,
2539 enums: &[],
2540 },
2541 ],
2542 omembers: &[
2543 ("templateArn", K::Str),
2544 ("templateName", K::Str),
2545 ("versionId", K::Int),
2546 ("isDefaultVersion", K::Bool),
2547 ],
2548 list_field: None,
2549 list_elems: &[],
2550 list_scalar: false,
2551 req_payload: false,
2552 },
2553 OpMeta {
2554 op: "CreateRoleAlias",
2555 method: "POST",
2556 segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
2557 verb: Verb::Create,
2558 rtype: "role-aliases",
2559 nlabels: 1,
2560 has_input: true,
2561 errors: &[
2562 "InternalFailureException",
2563 "InvalidRequestException",
2564 "LimitExceededException",
2565 "ResourceAlreadyExistsException",
2566 "ServiceUnavailableException",
2567 "ThrottlingException",
2568 "UnauthorizedException",
2569 ],
2570 rules: &[
2571 Rule {
2572 wire: "roleAlias",
2573 src: Src::Label,
2574 req: true,
2575 kind: K::Str,
2576 min_len: Some(1),
2577 max_len: Some(128),
2578 min_val: None,
2579 max_val: None,
2580 enums: &[],
2581 },
2582 Rule {
2583 wire: "roleArn",
2584 src: Src::Body,
2585 req: true,
2586 kind: K::Str,
2587 min_len: Some(20),
2588 max_len: Some(2048),
2589 min_val: None,
2590 max_val: None,
2591 enums: &[],
2592 },
2593 Rule {
2594 wire: "credentialDurationSeconds",
2595 src: Src::Body,
2596 req: false,
2597 kind: K::Int,
2598 min_len: None,
2599 max_len: None,
2600 min_val: Some(900),
2601 max_val: Some(43200),
2602 enums: &[],
2603 },
2604 ],
2605 omembers: &[("roleAlias", K::Str), ("roleAliasArn", K::Str)],
2606 list_field: None,
2607 list_elems: &[],
2608 list_scalar: false,
2609 req_payload: false,
2610 },
2611 OpMeta {
2612 op: "CreateScheduledAudit",
2613 method: "POST",
2614 segs: &[
2615 Seg::Fixed("audit"),
2616 Seg::Fixed("scheduledaudits"),
2617 Seg::Label("scheduledAuditName"),
2618 ],
2619 verb: Verb::Create,
2620 rtype: "audit",
2621 nlabels: 1,
2622 has_input: true,
2623 errors: &[
2624 "InternalFailureException",
2625 "InvalidRequestException",
2626 "LimitExceededException",
2627 "ResourceAlreadyExistsException",
2628 "ThrottlingException",
2629 ],
2630 rules: &[
2631 Rule {
2632 wire: "frequency",
2633 src: Src::Body,
2634 req: true,
2635 kind: K::Str,
2636 min_len: None,
2637 max_len: None,
2638 min_val: None,
2639 max_val: None,
2640 enums: &["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY"],
2641 },
2642 Rule {
2643 wire: "dayOfWeek",
2644 src: Src::Body,
2645 req: false,
2646 kind: K::Str,
2647 min_len: None,
2648 max_len: None,
2649 min_val: None,
2650 max_val: None,
2651 enums: &["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"],
2652 },
2653 Rule {
2654 wire: "targetCheckNames",
2655 src: Src::Body,
2656 req: true,
2657 kind: K::List,
2658 min_len: None,
2659 max_len: None,
2660 min_val: None,
2661 max_val: None,
2662 enums: &[],
2663 },
2664 Rule {
2665 wire: "scheduledAuditName",
2666 src: Src::Label,
2667 req: true,
2668 kind: K::Str,
2669 min_len: Some(1),
2670 max_len: Some(128),
2671 min_val: None,
2672 max_val: None,
2673 enums: &[],
2674 },
2675 ],
2676 omembers: &[("scheduledAuditArn", K::Str)],
2677 list_field: None,
2678 list_elems: &[],
2679 list_scalar: false,
2680 req_payload: false,
2681 },
2682 OpMeta {
2683 op: "CreateSecurityProfile",
2684 method: "POST",
2685 segs: &[
2686 Seg::Fixed("security-profiles"),
2687 Seg::Label("securityProfileName"),
2688 ],
2689 verb: Verb::Create,
2690 rtype: "security-profiles",
2691 nlabels: 1,
2692 has_input: true,
2693 errors: &[
2694 "InternalFailureException",
2695 "InvalidRequestException",
2696 "ResourceAlreadyExistsException",
2697 "ThrottlingException",
2698 ],
2699 rules: &[
2700 Rule {
2701 wire: "securityProfileName",
2702 src: Src::Label,
2703 req: true,
2704 kind: K::Str,
2705 min_len: Some(1),
2706 max_len: Some(128),
2707 min_val: None,
2708 max_val: None,
2709 enums: &[],
2710 },
2711 Rule {
2712 wire: "securityProfileDescription",
2713 src: Src::Body,
2714 req: false,
2715 kind: K::Str,
2716 min_len: Some(0),
2717 max_len: Some(1000),
2718 min_val: None,
2719 max_val: None,
2720 enums: &[],
2721 },
2722 Rule {
2723 wire: "behaviors",
2724 src: Src::Body,
2725 req: false,
2726 kind: K::List,
2727 min_len: Some(0),
2728 max_len: Some(100),
2729 min_val: None,
2730 max_val: None,
2731 enums: &[],
2732 },
2733 ],
2734 omembers: &[
2735 ("securityProfileName", K::Str),
2736 ("securityProfileArn", K::Str),
2737 ],
2738 list_field: None,
2739 list_elems: &[],
2740 list_scalar: false,
2741 req_payload: false,
2742 },
2743 OpMeta {
2744 op: "CreateStream",
2745 method: "POST",
2746 segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
2747 verb: Verb::Create,
2748 rtype: "streams",
2749 nlabels: 1,
2750 has_input: true,
2751 errors: &[
2752 "InternalFailureException",
2753 "InvalidRequestException",
2754 "LimitExceededException",
2755 "ResourceAlreadyExistsException",
2756 "ResourceNotFoundException",
2757 "ServiceUnavailableException",
2758 "ThrottlingException",
2759 "UnauthorizedException",
2760 ],
2761 rules: &[
2762 Rule {
2763 wire: "streamId",
2764 src: Src::Label,
2765 req: true,
2766 kind: K::Str,
2767 min_len: Some(1),
2768 max_len: Some(128),
2769 min_val: None,
2770 max_val: None,
2771 enums: &[],
2772 },
2773 Rule {
2774 wire: "description",
2775 src: Src::Body,
2776 req: false,
2777 kind: K::Str,
2778 min_len: Some(0),
2779 max_len: Some(2028),
2780 min_val: None,
2781 max_val: None,
2782 enums: &[],
2783 },
2784 Rule {
2785 wire: "files",
2786 src: Src::Body,
2787 req: true,
2788 kind: K::List,
2789 min_len: Some(1),
2790 max_len: Some(50),
2791 min_val: None,
2792 max_val: None,
2793 enums: &[],
2794 },
2795 Rule {
2796 wire: "roleArn",
2797 src: Src::Body,
2798 req: true,
2799 kind: K::Str,
2800 min_len: Some(20),
2801 max_len: Some(2048),
2802 min_val: None,
2803 max_val: None,
2804 enums: &[],
2805 },
2806 ],
2807 omembers: &[
2808 ("streamId", K::Str),
2809 ("streamArn", K::Str),
2810 ("description", K::Str),
2811 ("streamVersion", K::Int),
2812 ],
2813 list_field: None,
2814 list_elems: &[],
2815 list_scalar: false,
2816 req_payload: false,
2817 },
2818 OpMeta {
2819 op: "CreateThing",
2820 method: "POST",
2821 segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
2822 verb: Verb::Create,
2823 rtype: "things",
2824 nlabels: 1,
2825 has_input: true,
2826 errors: &[
2827 "InternalFailureException",
2828 "InvalidRequestException",
2829 "ResourceAlreadyExistsException",
2830 "ResourceNotFoundException",
2831 "ServiceUnavailableException",
2832 "ThrottlingException",
2833 "UnauthorizedException",
2834 ],
2835 rules: &[
2836 Rule {
2837 wire: "thingName",
2838 src: Src::Label,
2839 req: true,
2840 kind: K::Str,
2841 min_len: Some(1),
2842 max_len: Some(128),
2843 min_val: None,
2844 max_val: None,
2845 enums: &[],
2846 },
2847 Rule {
2848 wire: "thingTypeName",
2849 src: Src::Body,
2850 req: false,
2851 kind: K::Str,
2852 min_len: Some(1),
2853 max_len: Some(128),
2854 min_val: None,
2855 max_val: None,
2856 enums: &[],
2857 },
2858 Rule {
2859 wire: "billingGroupName",
2860 src: Src::Body,
2861 req: false,
2862 kind: K::Str,
2863 min_len: Some(1),
2864 max_len: Some(128),
2865 min_val: None,
2866 max_val: None,
2867 enums: &[],
2868 },
2869 ],
2870 omembers: &[
2871 ("thingName", K::Str),
2872 ("thingArn", K::Str),
2873 ("thingId", K::Str),
2874 ],
2875 list_field: None,
2876 list_elems: &[],
2877 list_scalar: false,
2878 req_payload: false,
2879 },
2880 OpMeta {
2881 op: "CreateThingGroup",
2882 method: "POST",
2883 segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
2884 verb: Verb::Create,
2885 rtype: "thing-groups",
2886 nlabels: 1,
2887 has_input: true,
2888 errors: &[
2889 "InternalFailureException",
2890 "InvalidRequestException",
2891 "ResourceAlreadyExistsException",
2892 "ThrottlingException",
2893 ],
2894 rules: &[
2895 Rule {
2896 wire: "thingGroupName",
2897 src: Src::Label,
2898 req: true,
2899 kind: K::Str,
2900 min_len: Some(1),
2901 max_len: Some(128),
2902 min_val: None,
2903 max_val: None,
2904 enums: &[],
2905 },
2906 Rule {
2907 wire: "parentGroupName",
2908 src: Src::Body,
2909 req: false,
2910 kind: K::Str,
2911 min_len: Some(1),
2912 max_len: Some(128),
2913 min_val: None,
2914 max_val: None,
2915 enums: &[],
2916 },
2917 ],
2918 omembers: &[
2919 ("thingGroupName", K::Str),
2920 ("thingGroupArn", K::Str),
2921 ("thingGroupId", K::Str),
2922 ],
2923 list_field: None,
2924 list_elems: &[],
2925 list_scalar: false,
2926 req_payload: false,
2927 },
2928 OpMeta {
2929 op: "CreateThingType",
2930 method: "POST",
2931 segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
2932 verb: Verb::Create,
2933 rtype: "thing-types",
2934 nlabels: 1,
2935 has_input: true,
2936 errors: &[
2937 "InternalFailureException",
2938 "InvalidRequestException",
2939 "ResourceAlreadyExistsException",
2940 "ServiceUnavailableException",
2941 "ThrottlingException",
2942 "UnauthorizedException",
2943 ],
2944 rules: &[Rule {
2945 wire: "thingTypeName",
2946 src: Src::Label,
2947 req: true,
2948 kind: K::Str,
2949 min_len: Some(1),
2950 max_len: Some(128),
2951 min_val: None,
2952 max_val: None,
2953 enums: &[],
2954 }],
2955 omembers: &[
2956 ("thingTypeName", K::Str),
2957 ("thingTypeArn", K::Str),
2958 ("thingTypeId", K::Str),
2959 ],
2960 list_field: None,
2961 list_elems: &[],
2962 list_scalar: false,
2963 req_payload: false,
2964 },
2965 OpMeta {
2966 op: "CreateTopicRule",
2967 method: "POST",
2968 segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
2969 verb: Verb::Create,
2970 rtype: "rules",
2971 nlabels: 1,
2972 has_input: true,
2973 errors: &[
2974 "ConflictingResourceUpdateException",
2975 "InternalException",
2976 "InvalidRequestException",
2977 "ResourceAlreadyExistsException",
2978 "ServiceUnavailableException",
2979 "SqlParseException",
2980 "UnauthorizedException",
2981 ],
2982 rules: &[Rule {
2983 wire: "ruleName",
2984 src: Src::Label,
2985 req: true,
2986 kind: K::Str,
2987 min_len: Some(1),
2988 max_len: Some(128),
2989 min_val: None,
2990 max_val: None,
2991 enums: &[],
2992 }],
2993 omembers: &[],
2994 list_field: None,
2995 list_elems: &[],
2996 list_scalar: false,
2997 req_payload: true,
2998 },
2999 OpMeta {
3000 op: "CreateTopicRuleDestination",
3001 method: "POST",
3002 segs: &[Seg::Fixed("destinations")],
3003 verb: Verb::Action,
3004 rtype: "destinations",
3005 nlabels: 0,
3006 has_input: true,
3007 errors: &[
3008 "ConflictingResourceUpdateException",
3009 "InternalException",
3010 "InvalidRequestException",
3011 "ResourceAlreadyExistsException",
3012 "ServiceUnavailableException",
3013 "UnauthorizedException",
3014 ],
3015 rules: &[Rule {
3016 wire: "destinationConfiguration",
3017 src: Src::Body,
3018 req: true,
3019 kind: K::Struct,
3020 min_len: None,
3021 max_len: None,
3022 min_val: None,
3023 max_val: None,
3024 enums: &[],
3025 }],
3026 omembers: &[("topicRuleDestination", K::Struct)],
3027 list_field: None,
3028 list_elems: &[],
3029 list_scalar: false,
3030 req_payload: false,
3031 },
3032 OpMeta {
3033 op: "DeleteAccountAuditConfiguration",
3034 method: "DELETE",
3035 segs: &[Seg::Fixed("audit"), Seg::Fixed("configuration")],
3036 verb: Verb::Action,
3037 rtype: "audit",
3038 nlabels: 0,
3039 has_input: true,
3040 errors: &[
3041 "InternalFailureException",
3042 "InvalidRequestException",
3043 "ResourceNotFoundException",
3044 "ThrottlingException",
3045 ],
3046 rules: &[],
3047 omembers: &[],
3048 list_field: None,
3049 list_elems: &[],
3050 list_scalar: false,
3051 req_payload: false,
3052 },
3053 OpMeta {
3054 op: "DeleteAuditSuppression",
3055 method: "POST",
3056 segs: &[
3057 Seg::Fixed("audit"),
3058 Seg::Fixed("suppressions"),
3059 Seg::Fixed("delete"),
3060 ],
3061 verb: Verb::Action,
3062 rtype: "audit",
3063 nlabels: 0,
3064 has_input: true,
3065 errors: &[
3066 "InternalFailureException",
3067 "InvalidRequestException",
3068 "ThrottlingException",
3069 ],
3070 rules: &[
3071 Rule {
3072 wire: "checkName",
3073 src: Src::Body,
3074 req: true,
3075 kind: K::Str,
3076 min_len: None,
3077 max_len: None,
3078 min_val: None,
3079 max_val: None,
3080 enums: &[],
3081 },
3082 Rule {
3083 wire: "resourceIdentifier",
3084 src: Src::Body,
3085 req: true,
3086 kind: K::Struct,
3087 min_len: None,
3088 max_len: None,
3089 min_val: None,
3090 max_val: None,
3091 enums: &[],
3092 },
3093 ],
3094 omembers: &[],
3095 list_field: None,
3096 list_elems: &[],
3097 list_scalar: false,
3098 req_payload: false,
3099 },
3100 OpMeta {
3101 op: "DeleteAuthorizer",
3102 method: "DELETE",
3103 segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
3104 verb: Verb::Delete,
3105 rtype: "authorizer",
3106 nlabels: 1,
3107 has_input: true,
3108 errors: &[
3109 "DeleteConflictException",
3110 "InternalFailureException",
3111 "InvalidRequestException",
3112 "ResourceNotFoundException",
3113 "ServiceUnavailableException",
3114 "ThrottlingException",
3115 "UnauthorizedException",
3116 ],
3117 rules: &[Rule {
3118 wire: "authorizerName",
3119 src: Src::Label,
3120 req: true,
3121 kind: K::Str,
3122 min_len: Some(1),
3123 max_len: Some(128),
3124 min_val: None,
3125 max_val: None,
3126 enums: &[],
3127 }],
3128 omembers: &[],
3129 list_field: None,
3130 list_elems: &[],
3131 list_scalar: false,
3132 req_payload: false,
3133 },
3134 OpMeta {
3135 op: "DeleteBillingGroup",
3136 method: "DELETE",
3137 segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
3138 verb: Verb::Delete,
3139 rtype: "billing-groups",
3140 nlabels: 1,
3141 has_input: true,
3142 errors: &[
3143 "InternalFailureException",
3144 "InvalidRequestException",
3145 "ThrottlingException",
3146 "VersionConflictException",
3147 ],
3148 rules: &[Rule {
3149 wire: "billingGroupName",
3150 src: Src::Label,
3151 req: true,
3152 kind: K::Str,
3153 min_len: Some(1),
3154 max_len: Some(128),
3155 min_val: None,
3156 max_val: None,
3157 enums: &[],
3158 }],
3159 omembers: &[],
3160 list_field: None,
3161 list_elems: &[],
3162 list_scalar: false,
3163 req_payload: false,
3164 },
3165 OpMeta {
3166 op: "DeleteCACertificate",
3167 method: "DELETE",
3168 segs: &[Seg::Fixed("cacertificate"), Seg::Label("certificateId")],
3169 verb: Verb::Delete,
3170 rtype: "cacertificate",
3171 nlabels: 1,
3172 has_input: true,
3173 errors: &[
3174 "CertificateStateException",
3175 "InternalFailureException",
3176 "InvalidRequestException",
3177 "ResourceNotFoundException",
3178 "ServiceUnavailableException",
3179 "ThrottlingException",
3180 "UnauthorizedException",
3181 ],
3182 rules: &[Rule {
3183 wire: "certificateId",
3184 src: Src::Label,
3185 req: true,
3186 kind: K::Str,
3187 min_len: Some(64),
3188 max_len: Some(64),
3189 min_val: None,
3190 max_val: None,
3191 enums: &[],
3192 }],
3193 omembers: &[],
3194 list_field: None,
3195 list_elems: &[],
3196 list_scalar: false,
3197 req_payload: false,
3198 },
3199 OpMeta {
3200 op: "DeleteCertificate",
3201 method: "DELETE",
3202 segs: &[Seg::Fixed("certificates"), Seg::Label("certificateId")],
3203 verb: Verb::Delete,
3204 rtype: "certificates",
3205 nlabels: 1,
3206 has_input: true,
3207 errors: &[
3208 "CertificateStateException",
3209 "DeleteConflictException",
3210 "InternalFailureException",
3211 "InvalidRequestException",
3212 "ResourceNotFoundException",
3213 "ServiceUnavailableException",
3214 "ThrottlingException",
3215 "UnauthorizedException",
3216 ],
3217 rules: &[Rule {
3218 wire: "certificateId",
3219 src: Src::Label,
3220 req: true,
3221 kind: K::Str,
3222 min_len: Some(64),
3223 max_len: Some(64),
3224 min_val: None,
3225 max_val: None,
3226 enums: &[],
3227 }],
3228 omembers: &[],
3229 list_field: None,
3230 list_elems: &[],
3231 list_scalar: false,
3232 req_payload: false,
3233 },
3234 OpMeta {
3235 op: "DeleteCertificateProvider",
3236 method: "DELETE",
3237 segs: &[
3238 Seg::Fixed("certificate-providers"),
3239 Seg::Label("certificateProviderName"),
3240 ],
3241 verb: Verb::Delete,
3242 rtype: "certificate-providers",
3243 nlabels: 1,
3244 has_input: true,
3245 errors: &[
3246 "DeleteConflictException",
3247 "InternalFailureException",
3248 "InvalidRequestException",
3249 "ResourceNotFoundException",
3250 "ServiceUnavailableException",
3251 "ThrottlingException",
3252 "UnauthorizedException",
3253 ],
3254 rules: &[Rule {
3255 wire: "certificateProviderName",
3256 src: Src::Label,
3257 req: true,
3258 kind: K::Str,
3259 min_len: Some(1),
3260 max_len: Some(128),
3261 min_val: None,
3262 max_val: None,
3263 enums: &[],
3264 }],
3265 omembers: &[],
3266 list_field: None,
3267 list_elems: &[],
3268 list_scalar: false,
3269 req_payload: false,
3270 },
3271 OpMeta {
3272 op: "DeleteCommand",
3273 method: "DELETE",
3274 segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
3275 verb: Verb::Delete,
3276 rtype: "commands",
3277 nlabels: 1,
3278 has_input: true,
3279 errors: &[
3280 "ConflictException",
3281 "InternalServerException",
3282 "ThrottlingException",
3283 "ValidationException",
3284 ],
3285 rules: &[Rule {
3286 wire: "commandId",
3287 src: Src::Label,
3288 req: true,
3289 kind: K::Str,
3290 min_len: Some(1),
3291 max_len: Some(64),
3292 min_val: None,
3293 max_val: None,
3294 enums: &[],
3295 }],
3296 omembers: &[],
3297 list_field: None,
3298 list_elems: &[],
3299 list_scalar: false,
3300 req_payload: false,
3301 },
3302 OpMeta {
3303 op: "DeleteCommandExecution",
3304 method: "DELETE",
3305 segs: &[Seg::Fixed("command-executions"), Seg::Label("executionId")],
3306 verb: Verb::Delete,
3307 rtype: "command-executions",
3308 nlabels: 1,
3309 has_input: true,
3310 errors: &[
3311 "ConflictException",
3312 "InternalServerException",
3313 "ThrottlingException",
3314 "ValidationException",
3315 ],
3316 rules: &[
3317 Rule {
3318 wire: "executionId",
3319 src: Src::Label,
3320 req: true,
3321 kind: K::Str,
3322 min_len: Some(1),
3323 max_len: Some(64),
3324 min_val: None,
3325 max_val: None,
3326 enums: &[],
3327 },
3328 Rule {
3329 wire: "targetArn",
3330 src: Src::Query,
3331 req: true,
3332 kind: K::Str,
3333 min_len: Some(0),
3334 max_len: Some(2048),
3335 min_val: None,
3336 max_val: None,
3337 enums: &[],
3338 },
3339 ],
3340 omembers: &[],
3341 list_field: None,
3342 list_elems: &[],
3343 list_scalar: false,
3344 req_payload: false,
3345 },
3346 OpMeta {
3347 op: "DeleteCustomMetric",
3348 method: "DELETE",
3349 segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
3350 verb: Verb::Delete,
3351 rtype: "custom-metric",
3352 nlabels: 1,
3353 has_input: true,
3354 errors: &[
3355 "InternalFailureException",
3356 "InvalidRequestException",
3357 "ThrottlingException",
3358 ],
3359 rules: &[Rule {
3360 wire: "metricName",
3361 src: Src::Label,
3362 req: true,
3363 kind: K::Str,
3364 min_len: Some(1),
3365 max_len: Some(128),
3366 min_val: None,
3367 max_val: None,
3368 enums: &[],
3369 }],
3370 omembers: &[],
3371 list_field: None,
3372 list_elems: &[],
3373 list_scalar: false,
3374 req_payload: false,
3375 },
3376 OpMeta {
3377 op: "DeleteDimension",
3378 method: "DELETE",
3379 segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
3380 verb: Verb::Delete,
3381 rtype: "dimensions",
3382 nlabels: 1,
3383 has_input: true,
3384 errors: &[
3385 "InternalFailureException",
3386 "InvalidRequestException",
3387 "ThrottlingException",
3388 ],
3389 rules: &[Rule {
3390 wire: "name",
3391 src: Src::Label,
3392 req: true,
3393 kind: K::Str,
3394 min_len: Some(1),
3395 max_len: Some(128),
3396 min_val: None,
3397 max_val: None,
3398 enums: &[],
3399 }],
3400 omembers: &[],
3401 list_field: None,
3402 list_elems: &[],
3403 list_scalar: false,
3404 req_payload: false,
3405 },
3406 OpMeta {
3407 op: "DeleteDomainConfiguration",
3408 method: "DELETE",
3409 segs: &[
3410 Seg::Fixed("domainConfigurations"),
3411 Seg::Label("domainConfigurationName"),
3412 ],
3413 verb: Verb::Delete,
3414 rtype: "domainConfigurations",
3415 nlabels: 1,
3416 has_input: true,
3417 errors: &[
3418 "InternalFailureException",
3419 "InvalidRequestException",
3420 "ResourceNotFoundException",
3421 "ServiceUnavailableException",
3422 "ThrottlingException",
3423 "UnauthorizedException",
3424 ],
3425 rules: &[Rule {
3426 wire: "domainConfigurationName",
3427 src: Src::Label,
3428 req: true,
3429 kind: K::Str,
3430 min_len: Some(1),
3431 max_len: Some(128),
3432 min_val: None,
3433 max_val: None,
3434 enums: &[],
3435 }],
3436 omembers: &[],
3437 list_field: None,
3438 list_elems: &[],
3439 list_scalar: false,
3440 req_payload: false,
3441 },
3442 OpMeta {
3443 op: "DeleteDynamicThingGroup",
3444 method: "DELETE",
3445 segs: &[
3446 Seg::Fixed("dynamic-thing-groups"),
3447 Seg::Label("thingGroupName"),
3448 ],
3449 verb: Verb::Delete,
3450 rtype: "dynamic-thing-groups",
3451 nlabels: 1,
3452 has_input: true,
3453 errors: &[
3454 "InternalFailureException",
3455 "InvalidRequestException",
3456 "ThrottlingException",
3457 "VersionConflictException",
3458 ],
3459 rules: &[Rule {
3460 wire: "thingGroupName",
3461 src: Src::Label,
3462 req: true,
3463 kind: K::Str,
3464 min_len: Some(1),
3465 max_len: Some(128),
3466 min_val: None,
3467 max_val: None,
3468 enums: &[],
3469 }],
3470 omembers: &[],
3471 list_field: None,
3472 list_elems: &[],
3473 list_scalar: false,
3474 req_payload: false,
3475 },
3476 OpMeta {
3477 op: "DeleteFleetMetric",
3478 method: "DELETE",
3479 segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
3480 verb: Verb::Delete,
3481 rtype: "fleet-metric",
3482 nlabels: 1,
3483 has_input: true,
3484 errors: &[
3485 "InternalFailureException",
3486 "InvalidRequestException",
3487 "ServiceUnavailableException",
3488 "ThrottlingException",
3489 "UnauthorizedException",
3490 "VersionConflictException",
3491 ],
3492 rules: &[Rule {
3493 wire: "metricName",
3494 src: Src::Label,
3495 req: true,
3496 kind: K::Str,
3497 min_len: Some(1),
3498 max_len: Some(128),
3499 min_val: None,
3500 max_val: None,
3501 enums: &[],
3502 }],
3503 omembers: &[],
3504 list_field: None,
3505 list_elems: &[],
3506 list_scalar: false,
3507 req_payload: false,
3508 },
3509 OpMeta {
3510 op: "DeleteJob",
3511 method: "DELETE",
3512 segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
3513 verb: Verb::Delete,
3514 rtype: "jobs",
3515 nlabels: 1,
3516 has_input: true,
3517 errors: &[
3518 "InvalidRequestException",
3519 "InvalidStateTransitionException",
3520 "LimitExceededException",
3521 "ResourceNotFoundException",
3522 "ServiceUnavailableException",
3523 "ThrottlingException",
3524 ],
3525 rules: &[Rule {
3526 wire: "jobId",
3527 src: Src::Label,
3528 req: true,
3529 kind: K::Str,
3530 min_len: Some(1),
3531 max_len: Some(64),
3532 min_val: None,
3533 max_val: None,
3534 enums: &[],
3535 }],
3536 omembers: &[],
3537 list_field: None,
3538 list_elems: &[],
3539 list_scalar: false,
3540 req_payload: false,
3541 },
3542 OpMeta {
3543 op: "DeleteJobExecution",
3544 method: "DELETE",
3545 segs: &[
3546 Seg::Fixed("things"),
3547 Seg::Label("thingName"),
3548 Seg::Fixed("jobs"),
3549 Seg::Label("jobId"),
3550 Seg::Fixed("executionNumber"),
3551 Seg::Label("executionNumber"),
3552 ],
3553 verb: Verb::Delete,
3554 rtype: "things",
3555 nlabels: 3,
3556 has_input: true,
3557 errors: &[
3558 "InvalidRequestException",
3559 "InvalidStateTransitionException",
3560 "ResourceNotFoundException",
3561 "ServiceUnavailableException",
3562 "ThrottlingException",
3563 ],
3564 rules: &[
3565 Rule {
3566 wire: "jobId",
3567 src: Src::Label,
3568 req: true,
3569 kind: K::Str,
3570 min_len: Some(1),
3571 max_len: Some(64),
3572 min_val: None,
3573 max_val: None,
3574 enums: &[],
3575 },
3576 Rule {
3577 wire: "thingName",
3578 src: Src::Label,
3579 req: true,
3580 kind: K::Str,
3581 min_len: Some(1),
3582 max_len: Some(128),
3583 min_val: None,
3584 max_val: None,
3585 enums: &[],
3586 },
3587 Rule {
3588 wire: "executionNumber",
3589 src: Src::Label,
3590 req: true,
3591 kind: K::Int,
3592 min_len: None,
3593 max_len: None,
3594 min_val: None,
3595 max_val: None,
3596 enums: &[],
3597 },
3598 ],
3599 omembers: &[],
3600 list_field: None,
3601 list_elems: &[],
3602 list_scalar: false,
3603 req_payload: false,
3604 },
3605 OpMeta {
3606 op: "DeleteJobTemplate",
3607 method: "DELETE",
3608 segs: &[Seg::Fixed("job-templates"), Seg::Label("jobTemplateId")],
3609 verb: Verb::Delete,
3610 rtype: "job-templates",
3611 nlabels: 1,
3612 has_input: true,
3613 errors: &[
3614 "InternalFailureException",
3615 "InvalidRequestException",
3616 "ResourceNotFoundException",
3617 "ThrottlingException",
3618 ],
3619 rules: &[Rule {
3620 wire: "jobTemplateId",
3621 src: Src::Label,
3622 req: true,
3623 kind: K::Str,
3624 min_len: Some(1),
3625 max_len: Some(64),
3626 min_val: None,
3627 max_val: None,
3628 enums: &[],
3629 }],
3630 omembers: &[],
3631 list_field: None,
3632 list_elems: &[],
3633 list_scalar: false,
3634 req_payload: false,
3635 },
3636 OpMeta {
3637 op: "DeleteMitigationAction",
3638 method: "DELETE",
3639 segs: &[
3640 Seg::Fixed("mitigationactions"),
3641 Seg::Fixed("actions"),
3642 Seg::Label("actionName"),
3643 ],
3644 verb: Verb::Delete,
3645 rtype: "mitigationactions",
3646 nlabels: 1,
3647 has_input: true,
3648 errors: &[
3649 "InternalFailureException",
3650 "InvalidRequestException",
3651 "ThrottlingException",
3652 ],
3653 rules: &[Rule {
3654 wire: "actionName",
3655 src: Src::Label,
3656 req: true,
3657 kind: K::Str,
3658 min_len: Some(0),
3659 max_len: Some(128),
3660 min_val: None,
3661 max_val: None,
3662 enums: &[],
3663 }],
3664 omembers: &[],
3665 list_field: None,
3666 list_elems: &[],
3667 list_scalar: false,
3668 req_payload: false,
3669 },
3670 OpMeta {
3671 op: "DeleteOTAUpdate",
3672 method: "DELETE",
3673 segs: &[Seg::Fixed("otaUpdates"), Seg::Label("otaUpdateId")],
3674 verb: Verb::Delete,
3675 rtype: "otaUpdates",
3676 nlabels: 1,
3677 has_input: true,
3678 errors: &[
3679 "InternalFailureException",
3680 "InvalidRequestException",
3681 "ResourceNotFoundException",
3682 "ServiceUnavailableException",
3683 "ThrottlingException",
3684 "UnauthorizedException",
3685 "VersionConflictException",
3686 ],
3687 rules: &[Rule {
3688 wire: "otaUpdateId",
3689 src: Src::Label,
3690 req: true,
3691 kind: K::Str,
3692 min_len: Some(1),
3693 max_len: Some(128),
3694 min_val: None,
3695 max_val: None,
3696 enums: &[],
3697 }],
3698 omembers: &[],
3699 list_field: None,
3700 list_elems: &[],
3701 list_scalar: false,
3702 req_payload: false,
3703 },
3704 OpMeta {
3705 op: "DeletePackage",
3706 method: "DELETE",
3707 segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
3708 verb: Verb::Delete,
3709 rtype: "packages",
3710 nlabels: 1,
3711 has_input: true,
3712 errors: &[
3713 "InternalServerException",
3714 "ThrottlingException",
3715 "ValidationException",
3716 ],
3717 rules: &[
3718 Rule {
3719 wire: "packageName",
3720 src: Src::Label,
3721 req: true,
3722 kind: K::Str,
3723 min_len: Some(1),
3724 max_len: Some(128),
3725 min_val: None,
3726 max_val: None,
3727 enums: &[],
3728 },
3729 Rule {
3730 wire: "clientToken",
3731 src: Src::Query,
3732 req: false,
3733 kind: K::Str,
3734 min_len: Some(36),
3735 max_len: Some(64),
3736 min_val: None,
3737 max_val: None,
3738 enums: &[],
3739 },
3740 ],
3741 omembers: &[],
3742 list_field: None,
3743 list_elems: &[],
3744 list_scalar: false,
3745 req_payload: false,
3746 },
3747 OpMeta {
3748 op: "DeletePackageVersion",
3749 method: "DELETE",
3750 segs: &[
3751 Seg::Fixed("packages"),
3752 Seg::Label("packageName"),
3753 Seg::Fixed("versions"),
3754 Seg::Label("versionName"),
3755 ],
3756 verb: Verb::Delete,
3757 rtype: "packages",
3758 nlabels: 2,
3759 has_input: true,
3760 errors: &[
3761 "InternalServerException",
3762 "ThrottlingException",
3763 "ValidationException",
3764 ],
3765 rules: &[
3766 Rule {
3767 wire: "packageName",
3768 src: Src::Label,
3769 req: true,
3770 kind: K::Str,
3771 min_len: Some(1),
3772 max_len: Some(128),
3773 min_val: None,
3774 max_val: None,
3775 enums: &[],
3776 },
3777 Rule {
3778 wire: "versionName",
3779 src: Src::Label,
3780 req: true,
3781 kind: K::Str,
3782 min_len: Some(1),
3783 max_len: Some(64),
3784 min_val: None,
3785 max_val: None,
3786 enums: &[],
3787 },
3788 Rule {
3789 wire: "clientToken",
3790 src: Src::Query,
3791 req: false,
3792 kind: K::Str,
3793 min_len: Some(36),
3794 max_len: Some(64),
3795 min_val: None,
3796 max_val: None,
3797 enums: &[],
3798 },
3799 ],
3800 omembers: &[],
3801 list_field: None,
3802 list_elems: &[],
3803 list_scalar: false,
3804 req_payload: false,
3805 },
3806 OpMeta {
3807 op: "DeletePolicy",
3808 method: "DELETE",
3809 segs: &[Seg::Fixed("policies"), Seg::Label("policyName")],
3810 verb: Verb::Delete,
3811 rtype: "policies",
3812 nlabels: 1,
3813 has_input: true,
3814 errors: &[
3815 "DeleteConflictException",
3816 "InternalFailureException",
3817 "InvalidRequestException",
3818 "ResourceNotFoundException",
3819 "ServiceUnavailableException",
3820 "ThrottlingException",
3821 "UnauthorizedException",
3822 ],
3823 rules: &[Rule {
3824 wire: "policyName",
3825 src: Src::Label,
3826 req: true,
3827 kind: K::Str,
3828 min_len: Some(1),
3829 max_len: Some(128),
3830 min_val: None,
3831 max_val: None,
3832 enums: &[],
3833 }],
3834 omembers: &[],
3835 list_field: None,
3836 list_elems: &[],
3837 list_scalar: false,
3838 req_payload: false,
3839 },
3840 OpMeta {
3841 op: "DeletePolicyVersion",
3842 method: "DELETE",
3843 segs: &[
3844 Seg::Fixed("policies"),
3845 Seg::Label("policyName"),
3846 Seg::Fixed("version"),
3847 Seg::Label("policyVersionId"),
3848 ],
3849 verb: Verb::Delete,
3850 rtype: "policies",
3851 nlabels: 2,
3852 has_input: true,
3853 errors: &[
3854 "DeleteConflictException",
3855 "InternalFailureException",
3856 "InvalidRequestException",
3857 "ResourceNotFoundException",
3858 "ServiceUnavailableException",
3859 "ThrottlingException",
3860 "UnauthorizedException",
3861 ],
3862 rules: &[
3863 Rule {
3864 wire: "policyName",
3865 src: Src::Label,
3866 req: true,
3867 kind: K::Str,
3868 min_len: Some(1),
3869 max_len: Some(128),
3870 min_val: None,
3871 max_val: None,
3872 enums: &[],
3873 },
3874 Rule {
3875 wire: "policyVersionId",
3876 src: Src::Label,
3877 req: true,
3878 kind: K::Str,
3879 min_len: None,
3880 max_len: None,
3881 min_val: None,
3882 max_val: None,
3883 enums: &[],
3884 },
3885 ],
3886 omembers: &[],
3887 list_field: None,
3888 list_elems: &[],
3889 list_scalar: false,
3890 req_payload: false,
3891 },
3892 OpMeta {
3893 op: "DeleteProvisioningTemplate",
3894 method: "DELETE",
3895 segs: &[
3896 Seg::Fixed("provisioning-templates"),
3897 Seg::Label("templateName"),
3898 ],
3899 verb: Verb::Delete,
3900 rtype: "provisioning-templates",
3901 nlabels: 1,
3902 has_input: true,
3903 errors: &[
3904 "ConflictingResourceUpdateException",
3905 "DeleteConflictException",
3906 "InternalFailureException",
3907 "InvalidRequestException",
3908 "ResourceNotFoundException",
3909 "ThrottlingException",
3910 "UnauthorizedException",
3911 ],
3912 rules: &[Rule {
3913 wire: "templateName",
3914 src: Src::Label,
3915 req: true,
3916 kind: K::Str,
3917 min_len: Some(1),
3918 max_len: Some(36),
3919 min_val: None,
3920 max_val: None,
3921 enums: &[],
3922 }],
3923 omembers: &[],
3924 list_field: None,
3925 list_elems: &[],
3926 list_scalar: false,
3927 req_payload: false,
3928 },
3929 OpMeta {
3930 op: "DeleteProvisioningTemplateVersion",
3931 method: "DELETE",
3932 segs: &[
3933 Seg::Fixed("provisioning-templates"),
3934 Seg::Label("templateName"),
3935 Seg::Fixed("versions"),
3936 Seg::Label("versionId"),
3937 ],
3938 verb: Verb::Delete,
3939 rtype: "provisioning-templates",
3940 nlabels: 2,
3941 has_input: true,
3942 errors: &[
3943 "ConflictingResourceUpdateException",
3944 "DeleteConflictException",
3945 "InternalFailureException",
3946 "InvalidRequestException",
3947 "ResourceNotFoundException",
3948 "ThrottlingException",
3949 "UnauthorizedException",
3950 ],
3951 rules: &[
3952 Rule {
3953 wire: "templateName",
3954 src: Src::Label,
3955 req: true,
3956 kind: K::Str,
3957 min_len: Some(1),
3958 max_len: Some(36),
3959 min_val: None,
3960 max_val: None,
3961 enums: &[],
3962 },
3963 Rule {
3964 wire: "versionId",
3965 src: Src::Label,
3966 req: true,
3967 kind: K::Int,
3968 min_len: None,
3969 max_len: None,
3970 min_val: None,
3971 max_val: None,
3972 enums: &[],
3973 },
3974 ],
3975 omembers: &[],
3976 list_field: None,
3977 list_elems: &[],
3978 list_scalar: false,
3979 req_payload: false,
3980 },
3981 OpMeta {
3982 op: "DeleteRegistrationCode",
3983 method: "DELETE",
3984 segs: &[Seg::Fixed("registrationcode")],
3985 verb: Verb::Action,
3986 rtype: "registrationcode",
3987 nlabels: 0,
3988 has_input: true,
3989 errors: &[
3990 "InternalFailureException",
3991 "ResourceNotFoundException",
3992 "ServiceUnavailableException",
3993 "ThrottlingException",
3994 "UnauthorizedException",
3995 ],
3996 rules: &[],
3997 omembers: &[],
3998 list_field: None,
3999 list_elems: &[],
4000 list_scalar: false,
4001 req_payload: false,
4002 },
4003 OpMeta {
4004 op: "DeleteRoleAlias",
4005 method: "DELETE",
4006 segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
4007 verb: Verb::Delete,
4008 rtype: "role-aliases",
4009 nlabels: 1,
4010 has_input: true,
4011 errors: &[
4012 "DeleteConflictException",
4013 "InternalFailureException",
4014 "InvalidRequestException",
4015 "ResourceNotFoundException",
4016 "ServiceUnavailableException",
4017 "ThrottlingException",
4018 "UnauthorizedException",
4019 ],
4020 rules: &[Rule {
4021 wire: "roleAlias",
4022 src: Src::Label,
4023 req: true,
4024 kind: K::Str,
4025 min_len: Some(1),
4026 max_len: Some(128),
4027 min_val: None,
4028 max_val: None,
4029 enums: &[],
4030 }],
4031 omembers: &[],
4032 list_field: None,
4033 list_elems: &[],
4034 list_scalar: false,
4035 req_payload: false,
4036 },
4037 OpMeta {
4038 op: "DeleteScheduledAudit",
4039 method: "DELETE",
4040 segs: &[
4041 Seg::Fixed("audit"),
4042 Seg::Fixed("scheduledaudits"),
4043 Seg::Label("scheduledAuditName"),
4044 ],
4045 verb: Verb::Delete,
4046 rtype: "audit",
4047 nlabels: 1,
4048 has_input: true,
4049 errors: &[
4050 "InternalFailureException",
4051 "InvalidRequestException",
4052 "ResourceNotFoundException",
4053 "ThrottlingException",
4054 ],
4055 rules: &[Rule {
4056 wire: "scheduledAuditName",
4057 src: Src::Label,
4058 req: true,
4059 kind: K::Str,
4060 min_len: Some(1),
4061 max_len: Some(128),
4062 min_val: None,
4063 max_val: None,
4064 enums: &[],
4065 }],
4066 omembers: &[],
4067 list_field: None,
4068 list_elems: &[],
4069 list_scalar: false,
4070 req_payload: false,
4071 },
4072 OpMeta {
4073 op: "DeleteSecurityProfile",
4074 method: "DELETE",
4075 segs: &[
4076 Seg::Fixed("security-profiles"),
4077 Seg::Label("securityProfileName"),
4078 ],
4079 verb: Verb::Delete,
4080 rtype: "security-profiles",
4081 nlabels: 1,
4082 has_input: true,
4083 errors: &[
4084 "InternalFailureException",
4085 "InvalidRequestException",
4086 "ThrottlingException",
4087 "VersionConflictException",
4088 ],
4089 rules: &[Rule {
4090 wire: "securityProfileName",
4091 src: Src::Label,
4092 req: true,
4093 kind: K::Str,
4094 min_len: Some(1),
4095 max_len: Some(128),
4096 min_val: None,
4097 max_val: None,
4098 enums: &[],
4099 }],
4100 omembers: &[],
4101 list_field: None,
4102 list_elems: &[],
4103 list_scalar: false,
4104 req_payload: false,
4105 },
4106 OpMeta {
4107 op: "DeleteStream",
4108 method: "DELETE",
4109 segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
4110 verb: Verb::Delete,
4111 rtype: "streams",
4112 nlabels: 1,
4113 has_input: true,
4114 errors: &[
4115 "DeleteConflictException",
4116 "InternalFailureException",
4117 "InvalidRequestException",
4118 "ResourceNotFoundException",
4119 "ServiceUnavailableException",
4120 "ThrottlingException",
4121 "UnauthorizedException",
4122 ],
4123 rules: &[Rule {
4124 wire: "streamId",
4125 src: Src::Label,
4126 req: true,
4127 kind: K::Str,
4128 min_len: Some(1),
4129 max_len: Some(128),
4130 min_val: None,
4131 max_val: None,
4132 enums: &[],
4133 }],
4134 omembers: &[],
4135 list_field: None,
4136 list_elems: &[],
4137 list_scalar: false,
4138 req_payload: false,
4139 },
4140 OpMeta {
4141 op: "DeleteThing",
4142 method: "DELETE",
4143 segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
4144 verb: Verb::Delete,
4145 rtype: "things",
4146 nlabels: 1,
4147 has_input: true,
4148 errors: &[
4149 "InternalFailureException",
4150 "InvalidRequestException",
4151 "ResourceNotFoundException",
4152 "ServiceUnavailableException",
4153 "ThrottlingException",
4154 "UnauthorizedException",
4155 "VersionConflictException",
4156 ],
4157 rules: &[Rule {
4158 wire: "thingName",
4159 src: Src::Label,
4160 req: true,
4161 kind: K::Str,
4162 min_len: Some(1),
4163 max_len: Some(128),
4164 min_val: None,
4165 max_val: None,
4166 enums: &[],
4167 }],
4168 omembers: &[],
4169 list_field: None,
4170 list_elems: &[],
4171 list_scalar: false,
4172 req_payload: false,
4173 },
4174 OpMeta {
4175 op: "DeleteThingGroup",
4176 method: "DELETE",
4177 segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
4178 verb: Verb::Delete,
4179 rtype: "thing-groups",
4180 nlabels: 1,
4181 has_input: true,
4182 errors: &[
4183 "InternalFailureException",
4184 "InvalidRequestException",
4185 "ThrottlingException",
4186 "VersionConflictException",
4187 ],
4188 rules: &[Rule {
4189 wire: "thingGroupName",
4190 src: Src::Label,
4191 req: true,
4192 kind: K::Str,
4193 min_len: Some(1),
4194 max_len: Some(128),
4195 min_val: None,
4196 max_val: None,
4197 enums: &[],
4198 }],
4199 omembers: &[],
4200 list_field: None,
4201 list_elems: &[],
4202 list_scalar: false,
4203 req_payload: false,
4204 },
4205 OpMeta {
4206 op: "DeleteThingType",
4207 method: "DELETE",
4208 segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
4209 verb: Verb::Delete,
4210 rtype: "thing-types",
4211 nlabels: 1,
4212 has_input: true,
4213 errors: &[
4214 "InternalFailureException",
4215 "InvalidRequestException",
4216 "ResourceNotFoundException",
4217 "ServiceUnavailableException",
4218 "ThrottlingException",
4219 "UnauthorizedException",
4220 ],
4221 rules: &[Rule {
4222 wire: "thingTypeName",
4223 src: Src::Label,
4224 req: true,
4225 kind: K::Str,
4226 min_len: Some(1),
4227 max_len: Some(128),
4228 min_val: None,
4229 max_val: None,
4230 enums: &[],
4231 }],
4232 omembers: &[],
4233 list_field: None,
4234 list_elems: &[],
4235 list_scalar: false,
4236 req_payload: false,
4237 },
4238 OpMeta {
4239 op: "DeleteTopicRule",
4240 method: "DELETE",
4241 segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
4242 verb: Verb::Delete,
4243 rtype: "rules",
4244 nlabels: 1,
4245 has_input: true,
4246 errors: &[
4247 "ConflictingResourceUpdateException",
4248 "InternalException",
4249 "InvalidRequestException",
4250 "ServiceUnavailableException",
4251 "UnauthorizedException",
4252 ],
4253 rules: &[Rule {
4254 wire: "ruleName",
4255 src: Src::Label,
4256 req: true,
4257 kind: K::Str,
4258 min_len: Some(1),
4259 max_len: Some(128),
4260 min_val: None,
4261 max_val: None,
4262 enums: &[],
4263 }],
4264 omembers: &[],
4265 list_field: None,
4266 list_elems: &[],
4267 list_scalar: false,
4268 req_payload: false,
4269 },
4270 OpMeta {
4271 op: "DeleteTopicRuleDestination",
4272 method: "DELETE",
4273 segs: &[Seg::Fixed("destinations"), Seg::Greedy("arn")],
4274 verb: Verb::Delete,
4275 rtype: "destinations",
4276 nlabels: 1,
4277 has_input: true,
4278 errors: &[
4279 "ConflictingResourceUpdateException",
4280 "InternalException",
4281 "InvalidRequestException",
4282 "ServiceUnavailableException",
4283 "UnauthorizedException",
4284 ],
4285 rules: &[Rule {
4286 wire: "arn",
4287 src: Src::Label,
4288 req: true,
4289 kind: K::Str,
4290 min_len: None,
4291 max_len: None,
4292 min_val: None,
4293 max_val: None,
4294 enums: &[],
4295 }],
4296 omembers: &[],
4297 list_field: None,
4298 list_elems: &[],
4299 list_scalar: false,
4300 req_payload: false,
4301 },
4302 OpMeta {
4303 op: "DeleteV2LoggingLevel",
4304 method: "DELETE",
4305 segs: &[Seg::Fixed("v2LoggingLevel")],
4306 verb: Verb::Action,
4307 rtype: "v2LoggingLevel",
4308 nlabels: 0,
4309 has_input: true,
4310 errors: &[
4311 "InternalException",
4312 "InvalidRequestException",
4313 "ServiceUnavailableException",
4314 ],
4315 rules: &[
4316 Rule {
4317 wire: "targetType",
4318 src: Src::Query,
4319 req: true,
4320 kind: K::Str,
4321 min_len: None,
4322 max_len: None,
4323 min_val: None,
4324 max_val: None,
4325 enums: &[
4326 "DEFAULT",
4327 "THING_GROUP",
4328 "CLIENT_ID",
4329 "SOURCE_IP",
4330 "PRINCIPAL_ID",
4331 ],
4332 },
4333 Rule {
4334 wire: "targetName",
4335 src: Src::Query,
4336 req: true,
4337 kind: K::Str,
4338 min_len: None,
4339 max_len: None,
4340 min_val: None,
4341 max_val: None,
4342 enums: &[],
4343 },
4344 ],
4345 omembers: &[],
4346 list_field: None,
4347 list_elems: &[],
4348 list_scalar: false,
4349 req_payload: false,
4350 },
4351 OpMeta {
4352 op: "DeprecateThingType",
4353 method: "POST",
4354 segs: &[
4355 Seg::Fixed("thing-types"),
4356 Seg::Label("thingTypeName"),
4357 Seg::Fixed("deprecate"),
4358 ],
4359 verb: Verb::Action,
4360 rtype: "thing-types",
4361 nlabels: 1,
4362 has_input: true,
4363 errors: &[
4364 "InternalFailureException",
4365 "InvalidRequestException",
4366 "ResourceNotFoundException",
4367 "ServiceUnavailableException",
4368 "ThrottlingException",
4369 "UnauthorizedException",
4370 ],
4371 rules: &[Rule {
4372 wire: "thingTypeName",
4373 src: Src::Label,
4374 req: true,
4375 kind: K::Str,
4376 min_len: Some(1),
4377 max_len: Some(128),
4378 min_val: None,
4379 max_val: None,
4380 enums: &[],
4381 }],
4382 omembers: &[],
4383 list_field: None,
4384 list_elems: &[],
4385 list_scalar: false,
4386 req_payload: false,
4387 },
4388 OpMeta {
4389 op: "DescribeAccountAuditConfiguration",
4390 method: "GET",
4391 segs: &[Seg::Fixed("audit"), Seg::Fixed("configuration")],
4392 verb: Verb::Action,
4393 rtype: "audit",
4394 nlabels: 0,
4395 has_input: true,
4396 errors: &["InternalFailureException", "ThrottlingException"],
4397 rules: &[],
4398 omembers: &[
4399 ("roleArn", K::Str),
4400 ("auditNotificationTargetConfigurations", K::Map),
4401 ("auditCheckConfigurations", K::Map),
4402 ],
4403 list_field: None,
4404 list_elems: &[],
4405 list_scalar: false,
4406 req_payload: false,
4407 },
4408 OpMeta {
4409 op: "DescribeAuditFinding",
4410 method: "GET",
4411 segs: &[
4412 Seg::Fixed("audit"),
4413 Seg::Fixed("findings"),
4414 Seg::Label("findingId"),
4415 ],
4416 verb: Verb::Get,
4417 rtype: "audit",
4418 nlabels: 1,
4419 has_input: true,
4420 errors: &[
4421 "InternalFailureException",
4422 "InvalidRequestException",
4423 "ResourceNotFoundException",
4424 "ThrottlingException",
4425 ],
4426 rules: &[Rule {
4427 wire: "findingId",
4428 src: Src::Label,
4429 req: true,
4430 kind: K::Str,
4431 min_len: Some(1),
4432 max_len: Some(128),
4433 min_val: None,
4434 max_val: None,
4435 enums: &[],
4436 }],
4437 omembers: &[("finding", K::Struct)],
4438 list_field: None,
4439 list_elems: &[],
4440 list_scalar: false,
4441 req_payload: false,
4442 },
4443 OpMeta {
4444 op: "DescribeAuditMitigationActionsTask",
4445 method: "GET",
4446 segs: &[
4447 Seg::Fixed("audit"),
4448 Seg::Fixed("mitigationactions"),
4449 Seg::Fixed("tasks"),
4450 Seg::Label("taskId"),
4451 ],
4452 verb: Verb::Get,
4453 rtype: "audit",
4454 nlabels: 1,
4455 has_input: true,
4456 errors: &[
4457 "InternalFailureException",
4458 "InvalidRequestException",
4459 "ResourceNotFoundException",
4460 "ThrottlingException",
4461 ],
4462 rules: &[Rule {
4463 wire: "taskId",
4464 src: Src::Label,
4465 req: true,
4466 kind: K::Str,
4467 min_len: Some(1),
4468 max_len: Some(128),
4469 min_val: None,
4470 max_val: None,
4471 enums: &[],
4472 }],
4473 omembers: &[
4474 ("taskStatus", K::Str),
4475 ("startTime", K::Ts),
4476 ("endTime", K::Ts),
4477 ("taskStatistics", K::Map),
4478 ("target", K::Struct),
4479 ("auditCheckToActionsMapping", K::Map),
4480 ("actionsDefinition", K::List),
4481 ],
4482 list_field: Some("actionsDefinition"),
4483 list_elems: &[
4484 ("name", K::Str),
4485 ("id", K::Str),
4486 ("roleArn", K::Str),
4487 ("actionParams", K::Struct),
4488 ],
4489 list_scalar: false,
4490 req_payload: false,
4491 },
4492 OpMeta {
4493 op: "DescribeAuditSuppression",
4494 method: "POST",
4495 segs: &[
4496 Seg::Fixed("audit"),
4497 Seg::Fixed("suppressions"),
4498 Seg::Fixed("describe"),
4499 ],
4500 verb: Verb::Action,
4501 rtype: "audit",
4502 nlabels: 0,
4503 has_input: true,
4504 errors: &[
4505 "InternalFailureException",
4506 "InvalidRequestException",
4507 "ResourceNotFoundException",
4508 "ThrottlingException",
4509 ],
4510 rules: &[
4511 Rule {
4512 wire: "checkName",
4513 src: Src::Body,
4514 req: true,
4515 kind: K::Str,
4516 min_len: None,
4517 max_len: None,
4518 min_val: None,
4519 max_val: None,
4520 enums: &[],
4521 },
4522 Rule {
4523 wire: "resourceIdentifier",
4524 src: Src::Body,
4525 req: true,
4526 kind: K::Struct,
4527 min_len: None,
4528 max_len: None,
4529 min_val: None,
4530 max_val: None,
4531 enums: &[],
4532 },
4533 ],
4534 omembers: &[
4535 ("checkName", K::Str),
4536 ("resourceIdentifier", K::Struct),
4537 ("expirationDate", K::Ts),
4538 ("suppressIndefinitely", K::Bool),
4539 ("description", K::Str),
4540 ],
4541 list_field: None,
4542 list_elems: &[],
4543 list_scalar: false,
4544 req_payload: false,
4545 },
4546 OpMeta {
4547 op: "DescribeAuditTask",
4548 method: "GET",
4549 segs: &[
4550 Seg::Fixed("audit"),
4551 Seg::Fixed("tasks"),
4552 Seg::Label("taskId"),
4553 ],
4554 verb: Verb::Get,
4555 rtype: "audit",
4556 nlabels: 1,
4557 has_input: true,
4558 errors: &[
4559 "InternalFailureException",
4560 "InvalidRequestException",
4561 "ResourceNotFoundException",
4562 "ThrottlingException",
4563 ],
4564 rules: &[Rule {
4565 wire: "taskId",
4566 src: Src::Label,
4567 req: true,
4568 kind: K::Str,
4569 min_len: Some(1),
4570 max_len: Some(40),
4571 min_val: None,
4572 max_val: None,
4573 enums: &[],
4574 }],
4575 omembers: &[
4576 ("taskStatus", K::Str),
4577 ("taskType", K::Str),
4578 ("taskStartTime", K::Ts),
4579 ("taskStatistics", K::Struct),
4580 ("scheduledAuditName", K::Str),
4581 ("auditDetails", K::Map),
4582 ],
4583 list_field: None,
4584 list_elems: &[],
4585 list_scalar: false,
4586 req_payload: false,
4587 },
4588 OpMeta {
4589 op: "DescribeAuthorizer",
4590 method: "GET",
4591 segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
4592 verb: Verb::Get,
4593 rtype: "authorizer",
4594 nlabels: 1,
4595 has_input: true,
4596 errors: &[
4597 "InternalFailureException",
4598 "InvalidRequestException",
4599 "ResourceNotFoundException",
4600 "ServiceUnavailableException",
4601 "ThrottlingException",
4602 "UnauthorizedException",
4603 ],
4604 rules: &[Rule {
4605 wire: "authorizerName",
4606 src: Src::Label,
4607 req: true,
4608 kind: K::Str,
4609 min_len: Some(1),
4610 max_len: Some(128),
4611 min_val: None,
4612 max_val: None,
4613 enums: &[],
4614 }],
4615 omembers: &[("authorizerDescription", K::Struct)],
4616 list_field: None,
4617 list_elems: &[],
4618 list_scalar: false,
4619 req_payload: false,
4620 },
4621 OpMeta {
4622 op: "DescribeBillingGroup",
4623 method: "GET",
4624 segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
4625 verb: Verb::Get,
4626 rtype: "billing-groups",
4627 nlabels: 1,
4628 has_input: true,
4629 errors: &[
4630 "InternalFailureException",
4631 "InvalidRequestException",
4632 "ResourceNotFoundException",
4633 "ThrottlingException",
4634 ],
4635 rules: &[Rule {
4636 wire: "billingGroupName",
4637 src: Src::Label,
4638 req: true,
4639 kind: K::Str,
4640 min_len: Some(1),
4641 max_len: Some(128),
4642 min_val: None,
4643 max_val: None,
4644 enums: &[],
4645 }],
4646 omembers: &[
4647 ("billingGroupName", K::Str),
4648 ("billingGroupId", K::Str),
4649 ("billingGroupArn", K::Str),
4650 ("version", K::Int),
4651 ("billingGroupProperties", K::Struct),
4652 ("billingGroupMetadata", K::Struct),
4653 ],
4654 list_field: None,
4655 list_elems: &[],
4656 list_scalar: false,
4657 req_payload: false,
4658 },
4659 OpMeta {
4660 op: "DescribeCACertificate",
4661 method: "GET",
4662 segs: &[Seg::Fixed("cacertificate"), Seg::Label("certificateId")],
4663 verb: Verb::Get,
4664 rtype: "cacertificate",
4665 nlabels: 1,
4666 has_input: true,
4667 errors: &[
4668 "InternalFailureException",
4669 "InvalidRequestException",
4670 "ResourceNotFoundException",
4671 "ServiceUnavailableException",
4672 "ThrottlingException",
4673 "UnauthorizedException",
4674 ],
4675 rules: &[Rule {
4676 wire: "certificateId",
4677 src: Src::Label,
4678 req: true,
4679 kind: K::Str,
4680 min_len: Some(64),
4681 max_len: Some(64),
4682 min_val: None,
4683 max_val: None,
4684 enums: &[],
4685 }],
4686 omembers: &[
4687 ("certificateDescription", K::Struct),
4688 ("registrationConfig", K::Struct),
4689 ],
4690 list_field: None,
4691 list_elems: &[],
4692 list_scalar: false,
4693 req_payload: false,
4694 },
4695 OpMeta {
4696 op: "DescribeCertificate",
4697 method: "GET",
4698 segs: &[Seg::Fixed("certificates"), Seg::Label("certificateId")],
4699 verb: Verb::Get,
4700 rtype: "certificates",
4701 nlabels: 1,
4702 has_input: true,
4703 errors: &[
4704 "InternalFailureException",
4705 "InvalidRequestException",
4706 "ResourceNotFoundException",
4707 "ServiceUnavailableException",
4708 "ThrottlingException",
4709 "UnauthorizedException",
4710 ],
4711 rules: &[Rule {
4712 wire: "certificateId",
4713 src: Src::Label,
4714 req: true,
4715 kind: K::Str,
4716 min_len: Some(64),
4717 max_len: Some(64),
4718 min_val: None,
4719 max_val: None,
4720 enums: &[],
4721 }],
4722 omembers: &[("certificateDescription", K::Struct)],
4723 list_field: None,
4724 list_elems: &[],
4725 list_scalar: false,
4726 req_payload: false,
4727 },
4728 OpMeta {
4729 op: "DescribeCertificateProvider",
4730 method: "GET",
4731 segs: &[
4732 Seg::Fixed("certificate-providers"),
4733 Seg::Label("certificateProviderName"),
4734 ],
4735 verb: Verb::Get,
4736 rtype: "certificate-providers",
4737 nlabels: 1,
4738 has_input: true,
4739 errors: &[
4740 "InternalFailureException",
4741 "InvalidRequestException",
4742 "ResourceNotFoundException",
4743 "ServiceUnavailableException",
4744 "ThrottlingException",
4745 "UnauthorizedException",
4746 ],
4747 rules: &[Rule {
4748 wire: "certificateProviderName",
4749 src: Src::Label,
4750 req: true,
4751 kind: K::Str,
4752 min_len: Some(1),
4753 max_len: Some(128),
4754 min_val: None,
4755 max_val: None,
4756 enums: &[],
4757 }],
4758 omembers: &[
4759 ("certificateProviderName", K::Str),
4760 ("certificateProviderArn", K::Str),
4761 ("lambdaFunctionArn", K::Str),
4762 ("accountDefaultForOperations", K::List),
4763 ("creationDate", K::Ts),
4764 ("lastModifiedDate", K::Ts),
4765 ],
4766 list_field: Some("accountDefaultForOperations"),
4767 list_elems: &[],
4768 list_scalar: true,
4769 req_payload: false,
4770 },
4771 OpMeta {
4772 op: "DescribeCustomMetric",
4773 method: "GET",
4774 segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
4775 verb: Verb::Get,
4776 rtype: "custom-metric",
4777 nlabels: 1,
4778 has_input: true,
4779 errors: &[
4780 "InternalFailureException",
4781 "InvalidRequestException",
4782 "ResourceNotFoundException",
4783 "ThrottlingException",
4784 ],
4785 rules: &[Rule {
4786 wire: "metricName",
4787 src: Src::Label,
4788 req: true,
4789 kind: K::Str,
4790 min_len: Some(1),
4791 max_len: Some(128),
4792 min_val: None,
4793 max_val: None,
4794 enums: &[],
4795 }],
4796 omembers: &[
4797 ("metricName", K::Str),
4798 ("metricArn", K::Str),
4799 ("metricType", K::Str),
4800 ("displayName", K::Str),
4801 ("creationDate", K::Ts),
4802 ("lastModifiedDate", K::Ts),
4803 ],
4804 list_field: None,
4805 list_elems: &[],
4806 list_scalar: false,
4807 req_payload: false,
4808 },
4809 OpMeta {
4810 op: "DescribeDefaultAuthorizer",
4811 method: "GET",
4812 segs: &[Seg::Fixed("default-authorizer")],
4813 verb: Verb::Action,
4814 rtype: "default-authorizer",
4815 nlabels: 0,
4816 has_input: true,
4817 errors: &[
4818 "InternalFailureException",
4819 "InvalidRequestException",
4820 "ResourceNotFoundException",
4821 "ServiceUnavailableException",
4822 "ThrottlingException",
4823 "UnauthorizedException",
4824 ],
4825 rules: &[],
4826 omembers: &[("authorizerDescription", K::Struct)],
4827 list_field: None,
4828 list_elems: &[],
4829 list_scalar: false,
4830 req_payload: false,
4831 },
4832 OpMeta {
4833 op: "DescribeDetectMitigationActionsTask",
4834 method: "GET",
4835 segs: &[
4836 Seg::Fixed("detect"),
4837 Seg::Fixed("mitigationactions"),
4838 Seg::Fixed("tasks"),
4839 Seg::Label("taskId"),
4840 ],
4841 verb: Verb::Get,
4842 rtype: "detect",
4843 nlabels: 1,
4844 has_input: true,
4845 errors: &[
4846 "InternalFailureException",
4847 "InvalidRequestException",
4848 "ResourceNotFoundException",
4849 "ThrottlingException",
4850 ],
4851 rules: &[Rule {
4852 wire: "taskId",
4853 src: Src::Label,
4854 req: true,
4855 kind: K::Str,
4856 min_len: Some(1),
4857 max_len: Some(128),
4858 min_val: None,
4859 max_val: None,
4860 enums: &[],
4861 }],
4862 omembers: &[("taskSummary", K::Struct)],
4863 list_field: None,
4864 list_elems: &[],
4865 list_scalar: false,
4866 req_payload: false,
4867 },
4868 OpMeta {
4869 op: "DescribeDimension",
4870 method: "GET",
4871 segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
4872 verb: Verb::Get,
4873 rtype: "dimensions",
4874 nlabels: 1,
4875 has_input: true,
4876 errors: &[
4877 "InternalFailureException",
4878 "InvalidRequestException",
4879 "ResourceNotFoundException",
4880 "ThrottlingException",
4881 ],
4882 rules: &[Rule {
4883 wire: "name",
4884 src: Src::Label,
4885 req: true,
4886 kind: K::Str,
4887 min_len: Some(1),
4888 max_len: Some(128),
4889 min_val: None,
4890 max_val: None,
4891 enums: &[],
4892 }],
4893 omembers: &[
4894 ("name", K::Str),
4895 ("arn", K::Str),
4896 ("type", K::Str),
4897 ("stringValues", K::List),
4898 ("creationDate", K::Ts),
4899 ("lastModifiedDate", K::Ts),
4900 ],
4901 list_field: Some("stringValues"),
4902 list_elems: &[],
4903 list_scalar: true,
4904 req_payload: false,
4905 },
4906 OpMeta {
4907 op: "DescribeDomainConfiguration",
4908 method: "GET",
4909 segs: &[
4910 Seg::Fixed("domainConfigurations"),
4911 Seg::Label("domainConfigurationName"),
4912 ],
4913 verb: Verb::Get,
4914 rtype: "domainConfigurations",
4915 nlabels: 1,
4916 has_input: true,
4917 errors: &[
4918 "InternalFailureException",
4919 "InvalidRequestException",
4920 "ResourceNotFoundException",
4921 "ServiceUnavailableException",
4922 "ThrottlingException",
4923 "UnauthorizedException",
4924 ],
4925 rules: &[Rule {
4926 wire: "domainConfigurationName",
4927 src: Src::Label,
4928 req: true,
4929 kind: K::Str,
4930 min_len: Some(1),
4931 max_len: Some(128),
4932 min_val: None,
4933 max_val: None,
4934 enums: &[],
4935 }],
4936 omembers: &[
4937 ("domainConfigurationName", K::Str),
4938 ("domainConfigurationArn", K::Str),
4939 ("domainName", K::Str),
4940 ("serverCertificates", K::List),
4941 ("authorizerConfig", K::Struct),
4942 ("domainConfigurationStatus", K::Str),
4943 ("serviceType", K::Str),
4944 ("domainType", K::Str),
4945 ("lastStatusChangeDate", K::Ts),
4946 ("tlsConfig", K::Struct),
4947 ("serverCertificateConfig", K::Struct),
4948 ("authenticationType", K::Str),
4949 ("applicationProtocol", K::Str),
4950 ("clientCertificateConfig", K::Struct),
4951 ],
4952 list_field: Some("serverCertificates"),
4953 list_elems: &[
4954 ("serverCertificateArn", K::Str),
4955 ("serverCertificateStatus", K::Str),
4956 ("serverCertificateStatusDetail", K::Str),
4957 ],
4958 list_scalar: false,
4959 req_payload: false,
4960 },
4961 OpMeta {
4962 op: "DescribeEncryptionConfiguration",
4963 method: "GET",
4964 segs: &[Seg::Fixed("encryption-configuration")],
4965 verb: Verb::Action,
4966 rtype: "encryption-configuration",
4967 nlabels: 0,
4968 has_input: true,
4969 errors: &[
4970 "InternalFailureException",
4971 "InvalidRequestException",
4972 "ServiceUnavailableException",
4973 "ThrottlingException",
4974 "UnauthorizedException",
4975 ],
4976 rules: &[],
4977 omembers: &[
4978 ("encryptionType", K::Str),
4979 ("kmsKeyArn", K::Str),
4980 ("kmsAccessRoleArn", K::Str),
4981 ("configurationDetails", K::Struct),
4982 ("lastModifiedDate", K::Ts),
4983 ],
4984 list_field: None,
4985 list_elems: &[],
4986 list_scalar: false,
4987 req_payload: false,
4988 },
4989 OpMeta {
4990 op: "DescribeEndpoint",
4991 method: "GET",
4992 segs: &[Seg::Fixed("endpoint")],
4993 verb: Verb::Action,
4994 rtype: "endpoint",
4995 nlabels: 0,
4996 has_input: true,
4997 errors: &[
4998 "InternalFailureException",
4999 "InvalidRequestException",
5000 "ThrottlingException",
5001 "UnauthorizedException",
5002 ],
5003 rules: &[Rule {
5004 wire: "endpointType",
5005 src: Src::Query,
5006 req: false,
5007 kind: K::Str,
5008 min_len: Some(0),
5009 max_len: Some(128),
5010 min_val: None,
5011 max_val: None,
5012 enums: &[],
5013 }],
5014 omembers: &[("endpointAddress", K::Str)],
5015 list_field: None,
5016 list_elems: &[],
5017 list_scalar: false,
5018 req_payload: false,
5019 },
5020 OpMeta {
5021 op: "DescribeEventConfigurations",
5022 method: "GET",
5023 segs: &[Seg::Fixed("event-configurations")],
5024 verb: Verb::Action,
5025 rtype: "event-configurations",
5026 nlabels: 0,
5027 has_input: true,
5028 errors: &["InternalFailureException", "ThrottlingException"],
5029 rules: &[],
5030 omembers: &[
5031 ("eventConfigurations", K::Map),
5032 ("creationDate", K::Ts),
5033 ("lastModifiedDate", K::Ts),
5034 ],
5035 list_field: None,
5036 list_elems: &[],
5037 list_scalar: false,
5038 req_payload: false,
5039 },
5040 OpMeta {
5041 op: "DescribeFleetMetric",
5042 method: "GET",
5043 segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
5044 verb: Verb::Get,
5045 rtype: "fleet-metric",
5046 nlabels: 1,
5047 has_input: true,
5048 errors: &[
5049 "InternalFailureException",
5050 "InvalidRequestException",
5051 "ResourceNotFoundException",
5052 "ServiceUnavailableException",
5053 "ThrottlingException",
5054 "UnauthorizedException",
5055 ],
5056 rules: &[Rule {
5057 wire: "metricName",
5058 src: Src::Label,
5059 req: true,
5060 kind: K::Str,
5061 min_len: Some(1),
5062 max_len: Some(128),
5063 min_val: None,
5064 max_val: None,
5065 enums: &[],
5066 }],
5067 omembers: &[
5068 ("metricName", K::Str),
5069 ("queryString", K::Str),
5070 ("aggregationType", K::Struct),
5071 ("period", K::Int),
5072 ("aggregationField", K::Str),
5073 ("description", K::Str),
5074 ("queryVersion", K::Str),
5075 ("indexName", K::Str),
5076 ("creationDate", K::Ts),
5077 ("lastModifiedDate", K::Ts),
5078 ("unit", K::Str),
5079 ("version", K::Int),
5080 ("metricArn", K::Str),
5081 ],
5082 list_field: None,
5083 list_elems: &[],
5084 list_scalar: false,
5085 req_payload: false,
5086 },
5087 OpMeta {
5088 op: "DescribeIndex",
5089 method: "GET",
5090 segs: &[Seg::Fixed("indices"), Seg::Label("indexName")],
5091 verb: Verb::Get,
5092 rtype: "indices",
5093 nlabels: 1,
5094 has_input: true,
5095 errors: &[
5096 "InternalFailureException",
5097 "InvalidRequestException",
5098 "ResourceNotFoundException",
5099 "ServiceUnavailableException",
5100 "ThrottlingException",
5101 "UnauthorizedException",
5102 ],
5103 rules: &[Rule {
5104 wire: "indexName",
5105 src: Src::Label,
5106 req: true,
5107 kind: K::Str,
5108 min_len: Some(1),
5109 max_len: Some(128),
5110 min_val: None,
5111 max_val: None,
5112 enums: &[],
5113 }],
5114 omembers: &[
5115 ("indexName", K::Str),
5116 ("indexStatus", K::Str),
5117 ("schema", K::Str),
5118 ],
5119 list_field: None,
5120 list_elems: &[],
5121 list_scalar: false,
5122 req_payload: false,
5123 },
5124 OpMeta {
5125 op: "DescribeJob",
5126 method: "GET",
5127 segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
5128 verb: Verb::Get,
5129 rtype: "jobs",
5130 nlabels: 1,
5131 has_input: true,
5132 errors: &[
5133 "InvalidRequestException",
5134 "ResourceNotFoundException",
5135 "ServiceUnavailableException",
5136 "ThrottlingException",
5137 ],
5138 rules: &[Rule {
5139 wire: "jobId",
5140 src: Src::Label,
5141 req: true,
5142 kind: K::Str,
5143 min_len: Some(1),
5144 max_len: Some(64),
5145 min_val: None,
5146 max_val: None,
5147 enums: &[],
5148 }],
5149 omembers: &[("documentSource", K::Str), ("job", K::Struct)],
5150 list_field: None,
5151 list_elems: &[],
5152 list_scalar: false,
5153 req_payload: false,
5154 },
5155 OpMeta {
5156 op: "DescribeJobExecution",
5157 method: "GET",
5158 segs: &[
5159 Seg::Fixed("things"),
5160 Seg::Label("thingName"),
5161 Seg::Fixed("jobs"),
5162 Seg::Label("jobId"),
5163 ],
5164 verb: Verb::Get,
5165 rtype: "things",
5166 nlabels: 2,
5167 has_input: true,
5168 errors: &[
5169 "InvalidRequestException",
5170 "ResourceNotFoundException",
5171 "ServiceUnavailableException",
5172 "ThrottlingException",
5173 ],
5174 rules: &[
5175 Rule {
5176 wire: "jobId",
5177 src: Src::Label,
5178 req: true,
5179 kind: K::Str,
5180 min_len: Some(1),
5181 max_len: Some(64),
5182 min_val: None,
5183 max_val: None,
5184 enums: &[],
5185 },
5186 Rule {
5187 wire: "thingName",
5188 src: Src::Label,
5189 req: true,
5190 kind: K::Str,
5191 min_len: Some(1),
5192 max_len: Some(128),
5193 min_val: None,
5194 max_val: None,
5195 enums: &[],
5196 },
5197 ],
5198 omembers: &[("execution", K::Struct)],
5199 list_field: None,
5200 list_elems: &[],
5201 list_scalar: false,
5202 req_payload: false,
5203 },
5204 OpMeta {
5205 op: "DescribeJobTemplate",
5206 method: "GET",
5207 segs: &[Seg::Fixed("job-templates"), Seg::Label("jobTemplateId")],
5208 verb: Verb::Get,
5209 rtype: "job-templates",
5210 nlabels: 1,
5211 has_input: true,
5212 errors: &[
5213 "InternalFailureException",
5214 "InvalidRequestException",
5215 "ResourceNotFoundException",
5216 "ThrottlingException",
5217 ],
5218 rules: &[Rule {
5219 wire: "jobTemplateId",
5220 src: Src::Label,
5221 req: true,
5222 kind: K::Str,
5223 min_len: Some(1),
5224 max_len: Some(64),
5225 min_val: None,
5226 max_val: None,
5227 enums: &[],
5228 }],
5229 omembers: &[
5230 ("jobTemplateArn", K::Str),
5231 ("jobTemplateId", K::Str),
5232 ("description", K::Str),
5233 ("documentSource", K::Str),
5234 ("document", K::Str),
5235 ("createdAt", K::Ts),
5236 ("presignedUrlConfig", K::Struct),
5237 ("jobExecutionsRolloutConfig", K::Struct),
5238 ("abortConfig", K::Struct),
5239 ("timeoutConfig", K::Struct),
5240 ("jobExecutionsRetryConfig", K::Struct),
5241 ("maintenanceWindows", K::List),
5242 ("destinationPackageVersions", K::List),
5243 ],
5244 list_field: Some("maintenanceWindows"),
5245 list_elems: &[("startTime", K::Str), ("durationInMinutes", K::Int)],
5246 list_scalar: false,
5247 req_payload: false,
5248 },
5249 OpMeta {
5250 op: "DescribeManagedJobTemplate",
5251 method: "GET",
5252 segs: &[
5253 Seg::Fixed("managed-job-templates"),
5254 Seg::Label("templateName"),
5255 ],
5256 verb: Verb::Get,
5257 rtype: "managed-job-templates",
5258 nlabels: 1,
5259 has_input: true,
5260 errors: &[
5261 "InternalServerException",
5262 "InvalidRequestException",
5263 "ResourceNotFoundException",
5264 "ThrottlingException",
5265 ],
5266 rules: &[Rule {
5267 wire: "templateName",
5268 src: Src::Label,
5269 req: true,
5270 kind: K::Str,
5271 min_len: Some(1),
5272 max_len: Some(64),
5273 min_val: None,
5274 max_val: None,
5275 enums: &[],
5276 }],
5277 omembers: &[
5278 ("templateName", K::Str),
5279 ("templateArn", K::Str),
5280 ("description", K::Str),
5281 ("templateVersion", K::Str),
5282 ("environments", K::List),
5283 ("documentParameters", K::List),
5284 ("document", K::Str),
5285 ],
5286 list_field: Some("environments"),
5287 list_elems: &[],
5288 list_scalar: true,
5289 req_payload: false,
5290 },
5291 OpMeta {
5292 op: "DescribeMitigationAction",
5293 method: "GET",
5294 segs: &[
5295 Seg::Fixed("mitigationactions"),
5296 Seg::Fixed("actions"),
5297 Seg::Label("actionName"),
5298 ],
5299 verb: Verb::Get,
5300 rtype: "mitigationactions",
5301 nlabels: 1,
5302 has_input: true,
5303 errors: &[
5304 "InternalFailureException",
5305 "InvalidRequestException",
5306 "ResourceNotFoundException",
5307 "ThrottlingException",
5308 ],
5309 rules: &[Rule {
5310 wire: "actionName",
5311 src: Src::Label,
5312 req: true,
5313 kind: K::Str,
5314 min_len: Some(0),
5315 max_len: Some(128),
5316 min_val: None,
5317 max_val: None,
5318 enums: &[],
5319 }],
5320 omembers: &[
5321 ("actionName", K::Str),
5322 ("actionType", K::Str),
5323 ("actionArn", K::Str),
5324 ("actionId", K::Str),
5325 ("roleArn", K::Str),
5326 ("actionParams", K::Struct),
5327 ("creationDate", K::Ts),
5328 ("lastModifiedDate", K::Ts),
5329 ],
5330 list_field: None,
5331 list_elems: &[],
5332 list_scalar: false,
5333 req_payload: false,
5334 },
5335 OpMeta {
5336 op: "DescribeProvisioningTemplate",
5337 method: "GET",
5338 segs: &[
5339 Seg::Fixed("provisioning-templates"),
5340 Seg::Label("templateName"),
5341 ],
5342 verb: Verb::Get,
5343 rtype: "provisioning-templates",
5344 nlabels: 1,
5345 has_input: true,
5346 errors: &[
5347 "InternalFailureException",
5348 "InvalidRequestException",
5349 "ResourceNotFoundException",
5350 "ThrottlingException",
5351 "UnauthorizedException",
5352 ],
5353 rules: &[Rule {
5354 wire: "templateName",
5355 src: Src::Label,
5356 req: true,
5357 kind: K::Str,
5358 min_len: Some(1),
5359 max_len: Some(36),
5360 min_val: None,
5361 max_val: None,
5362 enums: &[],
5363 }],
5364 omembers: &[
5365 ("templateArn", K::Str),
5366 ("templateName", K::Str),
5367 ("description", K::Str),
5368 ("creationDate", K::Ts),
5369 ("lastModifiedDate", K::Ts),
5370 ("defaultVersionId", K::Int),
5371 ("templateBody", K::Str),
5372 ("enabled", K::Bool),
5373 ("provisioningRoleArn", K::Str),
5374 ("preProvisioningHook", K::Struct),
5375 ("type", K::Str),
5376 ],
5377 list_field: None,
5378 list_elems: &[],
5379 list_scalar: false,
5380 req_payload: false,
5381 },
5382 OpMeta {
5383 op: "DescribeProvisioningTemplateVersion",
5384 method: "GET",
5385 segs: &[
5386 Seg::Fixed("provisioning-templates"),
5387 Seg::Label("templateName"),
5388 Seg::Fixed("versions"),
5389 Seg::Label("versionId"),
5390 ],
5391 verb: Verb::Get,
5392 rtype: "provisioning-templates",
5393 nlabels: 2,
5394 has_input: true,
5395 errors: &[
5396 "InternalFailureException",
5397 "InvalidRequestException",
5398 "ResourceNotFoundException",
5399 "ThrottlingException",
5400 "UnauthorizedException",
5401 ],
5402 rules: &[
5403 Rule {
5404 wire: "templateName",
5405 src: Src::Label,
5406 req: true,
5407 kind: K::Str,
5408 min_len: Some(1),
5409 max_len: Some(36),
5410 min_val: None,
5411 max_val: None,
5412 enums: &[],
5413 },
5414 Rule {
5415 wire: "versionId",
5416 src: Src::Label,
5417 req: true,
5418 kind: K::Int,
5419 min_len: None,
5420 max_len: None,
5421 min_val: None,
5422 max_val: None,
5423 enums: &[],
5424 },
5425 ],
5426 omembers: &[
5427 ("versionId", K::Int),
5428 ("creationDate", K::Ts),
5429 ("templateBody", K::Str),
5430 ("isDefaultVersion", K::Bool),
5431 ],
5432 list_field: None,
5433 list_elems: &[],
5434 list_scalar: false,
5435 req_payload: false,
5436 },
5437 OpMeta {
5438 op: "DescribeRoleAlias",
5439 method: "GET",
5440 segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
5441 verb: Verb::Get,
5442 rtype: "role-aliases",
5443 nlabels: 1,
5444 has_input: true,
5445 errors: &[
5446 "InternalFailureException",
5447 "InvalidRequestException",
5448 "ResourceNotFoundException",
5449 "ServiceUnavailableException",
5450 "ThrottlingException",
5451 "UnauthorizedException",
5452 ],
5453 rules: &[Rule {
5454 wire: "roleAlias",
5455 src: Src::Label,
5456 req: true,
5457 kind: K::Str,
5458 min_len: Some(1),
5459 max_len: Some(128),
5460 min_val: None,
5461 max_val: None,
5462 enums: &[],
5463 }],
5464 omembers: &[("roleAliasDescription", K::Struct)],
5465 list_field: None,
5466 list_elems: &[],
5467 list_scalar: false,
5468 req_payload: false,
5469 },
5470 OpMeta {
5471 op: "DescribeScheduledAudit",
5472 method: "GET",
5473 segs: &[
5474 Seg::Fixed("audit"),
5475 Seg::Fixed("scheduledaudits"),
5476 Seg::Label("scheduledAuditName"),
5477 ],
5478 verb: Verb::Get,
5479 rtype: "audit",
5480 nlabels: 1,
5481 has_input: true,
5482 errors: &[
5483 "InternalFailureException",
5484 "InvalidRequestException",
5485 "ResourceNotFoundException",
5486 "ThrottlingException",
5487 ],
5488 rules: &[Rule {
5489 wire: "scheduledAuditName",
5490 src: Src::Label,
5491 req: true,
5492 kind: K::Str,
5493 min_len: Some(1),
5494 max_len: Some(128),
5495 min_val: None,
5496 max_val: None,
5497 enums: &[],
5498 }],
5499 omembers: &[
5500 ("frequency", K::Str),
5501 ("dayOfMonth", K::Str),
5502 ("dayOfWeek", K::Str),
5503 ("targetCheckNames", K::List),
5504 ("scheduledAuditName", K::Str),
5505 ("scheduledAuditArn", K::Str),
5506 ],
5507 list_field: Some("targetCheckNames"),
5508 list_elems: &[],
5509 list_scalar: true,
5510 req_payload: false,
5511 },
5512 OpMeta {
5513 op: "DescribeSecurityProfile",
5514 method: "GET",
5515 segs: &[
5516 Seg::Fixed("security-profiles"),
5517 Seg::Label("securityProfileName"),
5518 ],
5519 verb: Verb::Get,
5520 rtype: "security-profiles",
5521 nlabels: 1,
5522 has_input: true,
5523 errors: &[
5524 "InternalFailureException",
5525 "InvalidRequestException",
5526 "ResourceNotFoundException",
5527 "ThrottlingException",
5528 ],
5529 rules: &[Rule {
5530 wire: "securityProfileName",
5531 src: Src::Label,
5532 req: true,
5533 kind: K::Str,
5534 min_len: Some(1),
5535 max_len: Some(128),
5536 min_val: None,
5537 max_val: None,
5538 enums: &[],
5539 }],
5540 omembers: &[
5541 ("securityProfileName", K::Str),
5542 ("securityProfileArn", K::Str),
5543 ("securityProfileDescription", K::Str),
5544 ("behaviors", K::List),
5545 ("alertTargets", K::Map),
5546 ("additionalMetricsToRetain", K::List),
5547 ("additionalMetricsToRetainV2", K::List),
5548 ("version", K::Int),
5549 ("creationDate", K::Ts),
5550 ("lastModifiedDate", K::Ts),
5551 ("metricsExportConfig", K::Struct),
5552 ],
5553 list_field: Some("behaviors"),
5554 list_elems: &[
5555 ("name", K::Str),
5556 ("metric", K::Str),
5557 ("metricDimension", K::Struct),
5558 ("criteria", K::Struct),
5559 ("suppressAlerts", K::Bool),
5560 ("exportMetric", K::Bool),
5561 ],
5562 list_scalar: false,
5563 req_payload: false,
5564 },
5565 OpMeta {
5566 op: "DescribeStream",
5567 method: "GET",
5568 segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
5569 verb: Verb::Get,
5570 rtype: "streams",
5571 nlabels: 1,
5572 has_input: true,
5573 errors: &[
5574 "InternalFailureException",
5575 "InvalidRequestException",
5576 "ResourceNotFoundException",
5577 "ServiceUnavailableException",
5578 "ThrottlingException",
5579 "UnauthorizedException",
5580 ],
5581 rules: &[Rule {
5582 wire: "streamId",
5583 src: Src::Label,
5584 req: true,
5585 kind: K::Str,
5586 min_len: Some(1),
5587 max_len: Some(128),
5588 min_val: None,
5589 max_val: None,
5590 enums: &[],
5591 }],
5592 omembers: &[("streamInfo", K::Struct)],
5593 list_field: None,
5594 list_elems: &[],
5595 list_scalar: false,
5596 req_payload: false,
5597 },
5598 OpMeta {
5599 op: "DescribeThing",
5600 method: "GET",
5601 segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
5602 verb: Verb::Get,
5603 rtype: "things",
5604 nlabels: 1,
5605 has_input: true,
5606 errors: &[
5607 "InternalFailureException",
5608 "InvalidRequestException",
5609 "ResourceNotFoundException",
5610 "ServiceUnavailableException",
5611 "ThrottlingException",
5612 "UnauthorizedException",
5613 ],
5614 rules: &[Rule {
5615 wire: "thingName",
5616 src: Src::Label,
5617 req: true,
5618 kind: K::Str,
5619 min_len: Some(1),
5620 max_len: Some(128),
5621 min_val: None,
5622 max_val: None,
5623 enums: &[],
5624 }],
5625 omembers: &[
5626 ("defaultClientId", K::Str),
5627 ("thingName", K::Str),
5628 ("thingId", K::Str),
5629 ("thingArn", K::Str),
5630 ("thingTypeName", K::Str),
5631 ("attributes", K::Map),
5632 ("version", K::Int),
5633 ("billingGroupName", K::Str),
5634 ],
5635 list_field: None,
5636 list_elems: &[],
5637 list_scalar: false,
5638 req_payload: false,
5639 },
5640 OpMeta {
5641 op: "DescribeThingGroup",
5642 method: "GET",
5643 segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
5644 verb: Verb::Get,
5645 rtype: "thing-groups",
5646 nlabels: 1,
5647 has_input: true,
5648 errors: &[
5649 "InternalFailureException",
5650 "InvalidRequestException",
5651 "ResourceNotFoundException",
5652 "ThrottlingException",
5653 ],
5654 rules: &[Rule {
5655 wire: "thingGroupName",
5656 src: Src::Label,
5657 req: true,
5658 kind: K::Str,
5659 min_len: Some(1),
5660 max_len: Some(128),
5661 min_val: None,
5662 max_val: None,
5663 enums: &[],
5664 }],
5665 omembers: &[
5666 ("thingGroupName", K::Str),
5667 ("thingGroupId", K::Str),
5668 ("thingGroupArn", K::Str),
5669 ("version", K::Int),
5670 ("thingGroupProperties", K::Struct),
5671 ("thingGroupMetadata", K::Struct),
5672 ("indexName", K::Str),
5673 ("queryString", K::Str),
5674 ("queryVersion", K::Str),
5675 ("status", K::Str),
5676 ],
5677 list_field: None,
5678 list_elems: &[],
5679 list_scalar: false,
5680 req_payload: false,
5681 },
5682 OpMeta {
5683 op: "DescribeThingRegistrationTask",
5684 method: "GET",
5685 segs: &[Seg::Fixed("thing-registration-tasks"), Seg::Label("taskId")],
5686 verb: Verb::Get,
5687 rtype: "thing-registration-tasks",
5688 nlabels: 1,
5689 has_input: true,
5690 errors: &[
5691 "InternalFailureException",
5692 "InvalidRequestException",
5693 "ResourceNotFoundException",
5694 "ThrottlingException",
5695 "UnauthorizedException",
5696 ],
5697 rules: &[Rule {
5698 wire: "taskId",
5699 src: Src::Label,
5700 req: true,
5701 kind: K::Str,
5702 min_len: Some(0),
5703 max_len: Some(40),
5704 min_val: None,
5705 max_val: None,
5706 enums: &[],
5707 }],
5708 omembers: &[
5709 ("taskId", K::Str),
5710 ("creationDate", K::Ts),
5711 ("lastModifiedDate", K::Ts),
5712 ("templateBody", K::Str),
5713 ("inputFileBucket", K::Str),
5714 ("inputFileKey", K::Str),
5715 ("roleArn", K::Str),
5716 ("status", K::Str),
5717 ("message", K::Str),
5718 ("successCount", K::Int),
5719 ("failureCount", K::Int),
5720 ("percentageProgress", K::Int),
5721 ],
5722 list_field: None,
5723 list_elems: &[],
5724 list_scalar: false,
5725 req_payload: false,
5726 },
5727 OpMeta {
5728 op: "DescribeThingType",
5729 method: "GET",
5730 segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
5731 verb: Verb::Get,
5732 rtype: "thing-types",
5733 nlabels: 1,
5734 has_input: true,
5735 errors: &[
5736 "InternalFailureException",
5737 "InvalidRequestException",
5738 "ResourceNotFoundException",
5739 "ServiceUnavailableException",
5740 "ThrottlingException",
5741 "UnauthorizedException",
5742 ],
5743 rules: &[Rule {
5744 wire: "thingTypeName",
5745 src: Src::Label,
5746 req: true,
5747 kind: K::Str,
5748 min_len: Some(1),
5749 max_len: Some(128),
5750 min_val: None,
5751 max_val: None,
5752 enums: &[],
5753 }],
5754 omembers: &[
5755 ("thingTypeName", K::Str),
5756 ("thingTypeId", K::Str),
5757 ("thingTypeArn", K::Str),
5758 ("thingTypeProperties", K::Struct),
5759 ("thingTypeMetadata", K::Struct),
5760 ],
5761 list_field: None,
5762 list_elems: &[],
5763 list_scalar: false,
5764 req_payload: false,
5765 },
5766 OpMeta {
5767 op: "DetachPolicy",
5768 method: "POST",
5769 segs: &[Seg::Fixed("target-policies"), Seg::Label("policyName")],
5770 verb: Verb::Action,
5771 rtype: "target-policies",
5772 nlabels: 1,
5773 has_input: true,
5774 errors: &[
5775 "InternalFailureException",
5776 "InvalidRequestException",
5777 "LimitExceededException",
5778 "ServiceUnavailableException",
5779 "ThrottlingException",
5780 "UnauthorizedException",
5781 ],
5782 rules: &[
5783 Rule {
5784 wire: "policyName",
5785 src: Src::Label,
5786 req: true,
5787 kind: K::Str,
5788 min_len: Some(1),
5789 max_len: Some(128),
5790 min_val: None,
5791 max_val: None,
5792 enums: &[],
5793 },
5794 Rule {
5795 wire: "target",
5796 src: Src::Body,
5797 req: true,
5798 kind: K::Str,
5799 min_len: None,
5800 max_len: None,
5801 min_val: None,
5802 max_val: None,
5803 enums: &[],
5804 },
5805 ],
5806 omembers: &[],
5807 list_field: None,
5808 list_elems: &[],
5809 list_scalar: false,
5810 req_payload: false,
5811 },
5812 OpMeta {
5813 op: "DetachPrincipalPolicy",
5814 method: "DELETE",
5815 segs: &[Seg::Fixed("principal-policies"), Seg::Label("policyName")],
5816 verb: Verb::Action,
5817 rtype: "principal-policies",
5818 nlabels: 1,
5819 has_input: true,
5820 errors: &[
5821 "InternalFailureException",
5822 "InvalidRequestException",
5823 "ResourceNotFoundException",
5824 "ServiceUnavailableException",
5825 "ThrottlingException",
5826 "UnauthorizedException",
5827 ],
5828 rules: &[
5829 Rule {
5830 wire: "policyName",
5831 src: Src::Label,
5832 req: true,
5833 kind: K::Str,
5834 min_len: Some(1),
5835 max_len: Some(128),
5836 min_val: None,
5837 max_val: None,
5838 enums: &[],
5839 },
5840 Rule {
5841 wire: "x-amzn-iot-principal",
5842 src: Src::Header,
5843 req: true,
5844 kind: K::Str,
5845 min_len: None,
5846 max_len: None,
5847 min_val: None,
5848 max_val: None,
5849 enums: &[],
5850 },
5851 ],
5852 omembers: &[],
5853 list_field: None,
5854 list_elems: &[],
5855 list_scalar: false,
5856 req_payload: false,
5857 },
5858 OpMeta {
5859 op: "DetachSecurityProfile",
5860 method: "DELETE",
5861 segs: &[
5862 Seg::Fixed("security-profiles"),
5863 Seg::Label("securityProfileName"),
5864 Seg::Fixed("targets"),
5865 ],
5866 verb: Verb::Action,
5867 rtype: "security-profiles",
5868 nlabels: 1,
5869 has_input: true,
5870 errors: &[
5871 "InternalFailureException",
5872 "InvalidRequestException",
5873 "ResourceNotFoundException",
5874 "ThrottlingException",
5875 ],
5876 rules: &[
5877 Rule {
5878 wire: "securityProfileName",
5879 src: Src::Label,
5880 req: true,
5881 kind: K::Str,
5882 min_len: Some(1),
5883 max_len: Some(128),
5884 min_val: None,
5885 max_val: None,
5886 enums: &[],
5887 },
5888 Rule {
5889 wire: "securityProfileTargetArn",
5890 src: Src::Query,
5891 req: true,
5892 kind: K::Str,
5893 min_len: None,
5894 max_len: None,
5895 min_val: None,
5896 max_val: None,
5897 enums: &[],
5898 },
5899 ],
5900 omembers: &[],
5901 list_field: None,
5902 list_elems: &[],
5903 list_scalar: false,
5904 req_payload: false,
5905 },
5906 OpMeta {
5907 op: "DetachThingPrincipal",
5908 method: "DELETE",
5909 segs: &[
5910 Seg::Fixed("things"),
5911 Seg::Label("thingName"),
5912 Seg::Fixed("principals"),
5913 ],
5914 verb: Verb::Action,
5915 rtype: "things",
5916 nlabels: 1,
5917 has_input: true,
5918 errors: &[
5919 "InternalFailureException",
5920 "InvalidRequestException",
5921 "ResourceNotFoundException",
5922 "ServiceUnavailableException",
5923 "ThrottlingException",
5924 "UnauthorizedException",
5925 ],
5926 rules: &[
5927 Rule {
5928 wire: "thingName",
5929 src: Src::Label,
5930 req: true,
5931 kind: K::Str,
5932 min_len: Some(1),
5933 max_len: Some(128),
5934 min_val: None,
5935 max_val: None,
5936 enums: &[],
5937 },
5938 Rule {
5939 wire: "x-amzn-principal",
5940 src: Src::Header,
5941 req: true,
5942 kind: K::Str,
5943 min_len: None,
5944 max_len: None,
5945 min_val: None,
5946 max_val: None,
5947 enums: &[],
5948 },
5949 ],
5950 omembers: &[],
5951 list_field: None,
5952 list_elems: &[],
5953 list_scalar: false,
5954 req_payload: false,
5955 },
5956 OpMeta {
5957 op: "DisableTopicRule",
5958 method: "POST",
5959 segs: &[
5960 Seg::Fixed("rules"),
5961 Seg::Label("ruleName"),
5962 Seg::Fixed("disable"),
5963 ],
5964 verb: Verb::Action,
5965 rtype: "rules",
5966 nlabels: 1,
5967 has_input: true,
5968 errors: &[
5969 "ConflictingResourceUpdateException",
5970 "InternalException",
5971 "InvalidRequestException",
5972 "ServiceUnavailableException",
5973 "UnauthorizedException",
5974 ],
5975 rules: &[Rule {
5976 wire: "ruleName",
5977 src: Src::Label,
5978 req: true,
5979 kind: K::Str,
5980 min_len: Some(1),
5981 max_len: Some(128),
5982 min_val: None,
5983 max_val: None,
5984 enums: &[],
5985 }],
5986 omembers: &[],
5987 list_field: None,
5988 list_elems: &[],
5989 list_scalar: false,
5990 req_payload: false,
5991 },
5992 OpMeta {
5993 op: "DisassociateSbomFromPackageVersion",
5994 method: "DELETE",
5995 segs: &[
5996 Seg::Fixed("packages"),
5997 Seg::Label("packageName"),
5998 Seg::Fixed("versions"),
5999 Seg::Label("versionName"),
6000 Seg::Fixed("sbom"),
6001 ],
6002 verb: Verb::Action,
6003 rtype: "packages",
6004 nlabels: 2,
6005 has_input: true,
6006 errors: &[
6007 "ConflictException",
6008 "InternalServerException",
6009 "ResourceNotFoundException",
6010 "ThrottlingException",
6011 "ValidationException",
6012 ],
6013 rules: &[
6014 Rule {
6015 wire: "packageName",
6016 src: Src::Label,
6017 req: true,
6018 kind: K::Str,
6019 min_len: Some(1),
6020 max_len: Some(128),
6021 min_val: None,
6022 max_val: None,
6023 enums: &[],
6024 },
6025 Rule {
6026 wire: "versionName",
6027 src: Src::Label,
6028 req: true,
6029 kind: K::Str,
6030 min_len: Some(1),
6031 max_len: Some(64),
6032 min_val: None,
6033 max_val: None,
6034 enums: &[],
6035 },
6036 Rule {
6037 wire: "clientToken",
6038 src: Src::Query,
6039 req: false,
6040 kind: K::Str,
6041 min_len: Some(36),
6042 max_len: Some(64),
6043 min_val: None,
6044 max_val: None,
6045 enums: &[],
6046 },
6047 ],
6048 omembers: &[],
6049 list_field: None,
6050 list_elems: &[],
6051 list_scalar: false,
6052 req_payload: false,
6053 },
6054 OpMeta {
6055 op: "EnableTopicRule",
6056 method: "POST",
6057 segs: &[
6058 Seg::Fixed("rules"),
6059 Seg::Label("ruleName"),
6060 Seg::Fixed("enable"),
6061 ],
6062 verb: Verb::Action,
6063 rtype: "rules",
6064 nlabels: 1,
6065 has_input: true,
6066 errors: &[
6067 "ConflictingResourceUpdateException",
6068 "InternalException",
6069 "InvalidRequestException",
6070 "ServiceUnavailableException",
6071 "UnauthorizedException",
6072 ],
6073 rules: &[Rule {
6074 wire: "ruleName",
6075 src: Src::Label,
6076 req: true,
6077 kind: K::Str,
6078 min_len: Some(1),
6079 max_len: Some(128),
6080 min_val: None,
6081 max_val: None,
6082 enums: &[],
6083 }],
6084 omembers: &[],
6085 list_field: None,
6086 list_elems: &[],
6087 list_scalar: false,
6088 req_payload: false,
6089 },
6090 OpMeta {
6091 op: "GetBehaviorModelTrainingSummaries",
6092 method: "GET",
6093 segs: &[
6094 Seg::Fixed("behavior-model-training"),
6095 Seg::Fixed("summaries"),
6096 ],
6097 verb: Verb::Action,
6098 rtype: "behavior-model-training",
6099 nlabels: 0,
6100 has_input: true,
6101 errors: &[
6102 "InternalFailureException",
6103 "InvalidRequestException",
6104 "ResourceNotFoundException",
6105 "ThrottlingException",
6106 ],
6107 rules: &[
6108 Rule {
6109 wire: "securityProfileName",
6110 src: Src::Query,
6111 req: false,
6112 kind: K::Str,
6113 min_len: Some(1),
6114 max_len: Some(128),
6115 min_val: None,
6116 max_val: None,
6117 enums: &[],
6118 },
6119 Rule {
6120 wire: "maxResults",
6121 src: Src::Query,
6122 req: false,
6123 kind: K::Int,
6124 min_len: None,
6125 max_len: None,
6126 min_val: Some(1),
6127 max_val: Some(10),
6128 enums: &[],
6129 },
6130 ],
6131 omembers: &[("summaries", K::List), ("nextToken", K::Str)],
6132 list_field: Some("summaries"),
6133 list_elems: &[
6134 ("securityProfileName", K::Str),
6135 ("behaviorName", K::Str),
6136 ("trainingDataCollectionStartDate", K::Ts),
6137 ("modelStatus", K::Str),
6138 ("datapointsCollectionPercentage", K::Num),
6139 ("lastModelRefreshDate", K::Ts),
6140 ],
6141 list_scalar: false,
6142 req_payload: false,
6143 },
6144 OpMeta {
6145 op: "GetBucketsAggregation",
6146 method: "POST",
6147 segs: &[Seg::Fixed("indices"), Seg::Fixed("buckets")],
6148 verb: Verb::Action,
6149 rtype: "indices",
6150 nlabels: 0,
6151 has_input: true,
6152 errors: &[
6153 "IndexNotReadyException",
6154 "InternalFailureException",
6155 "InvalidAggregationException",
6156 "InvalidQueryException",
6157 "InvalidRequestException",
6158 "ResourceNotFoundException",
6159 "ServiceUnavailableException",
6160 "ThrottlingException",
6161 "UnauthorizedException",
6162 ],
6163 rules: &[
6164 Rule {
6165 wire: "indexName",
6166 src: Src::Body,
6167 req: false,
6168 kind: K::Str,
6169 min_len: Some(1),
6170 max_len: Some(128),
6171 min_val: None,
6172 max_val: None,
6173 enums: &[],
6174 },
6175 Rule {
6176 wire: "queryString",
6177 src: Src::Body,
6178 req: true,
6179 kind: K::Str,
6180 min_len: Some(1),
6181 max_len: None,
6182 min_val: None,
6183 max_val: None,
6184 enums: &[],
6185 },
6186 Rule {
6187 wire: "aggregationField",
6188 src: Src::Body,
6189 req: true,
6190 kind: K::Str,
6191 min_len: Some(1),
6192 max_len: None,
6193 min_val: None,
6194 max_val: None,
6195 enums: &[],
6196 },
6197 Rule {
6198 wire: "bucketsAggregationType",
6199 src: Src::Body,
6200 req: true,
6201 kind: K::Struct,
6202 min_len: None,
6203 max_len: None,
6204 min_val: None,
6205 max_val: None,
6206 enums: &[],
6207 },
6208 ],
6209 omembers: &[("totalCount", K::Int), ("buckets", K::List)],
6210 list_field: Some("buckets"),
6211 list_elems: &[("keyValue", K::Str), ("count", K::Int)],
6212 list_scalar: false,
6213 req_payload: false,
6214 },
6215 OpMeta {
6216 op: "GetCardinality",
6217 method: "POST",
6218 segs: &[Seg::Fixed("indices"), Seg::Fixed("cardinality")],
6219 verb: Verb::Action,
6220 rtype: "indices",
6221 nlabels: 0,
6222 has_input: true,
6223 errors: &[
6224 "IndexNotReadyException",
6225 "InternalFailureException",
6226 "InvalidAggregationException",
6227 "InvalidQueryException",
6228 "InvalidRequestException",
6229 "ResourceNotFoundException",
6230 "ServiceUnavailableException",
6231 "ThrottlingException",
6232 "UnauthorizedException",
6233 ],
6234 rules: &[
6235 Rule {
6236 wire: "indexName",
6237 src: Src::Body,
6238 req: false,
6239 kind: K::Str,
6240 min_len: Some(1),
6241 max_len: Some(128),
6242 min_val: None,
6243 max_val: None,
6244 enums: &[],
6245 },
6246 Rule {
6247 wire: "queryString",
6248 src: Src::Body,
6249 req: true,
6250 kind: K::Str,
6251 min_len: Some(1),
6252 max_len: None,
6253 min_val: None,
6254 max_val: None,
6255 enums: &[],
6256 },
6257 Rule {
6258 wire: "aggregationField",
6259 src: Src::Body,
6260 req: false,
6261 kind: K::Str,
6262 min_len: Some(1),
6263 max_len: None,
6264 min_val: None,
6265 max_val: None,
6266 enums: &[],
6267 },
6268 ],
6269 omembers: &[("cardinality", K::Int)],
6270 list_field: None,
6271 list_elems: &[],
6272 list_scalar: false,
6273 req_payload: false,
6274 },
6275 OpMeta {
6276 op: "GetCommand",
6277 method: "GET",
6278 segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
6279 verb: Verb::Get,
6280 rtype: "commands",
6281 nlabels: 1,
6282 has_input: true,
6283 errors: &[
6284 "InternalServerException",
6285 "ResourceNotFoundException",
6286 "ThrottlingException",
6287 "ValidationException",
6288 ],
6289 rules: &[Rule {
6290 wire: "commandId",
6291 src: Src::Label,
6292 req: true,
6293 kind: K::Str,
6294 min_len: Some(1),
6295 max_len: Some(64),
6296 min_val: None,
6297 max_val: None,
6298 enums: &[],
6299 }],
6300 omembers: &[
6301 ("commandId", K::Str),
6302 ("commandArn", K::Str),
6303 ("namespace", K::Str),
6304 ("displayName", K::Str),
6305 ("description", K::Str),
6306 ("mandatoryParameters", K::List),
6307 ("payload", K::Struct),
6308 ("payloadTemplate", K::Str),
6309 ("preprocessor", K::Struct),
6310 ("roleArn", K::Str),
6311 ("createdAt", K::Ts),
6312 ("lastUpdatedAt", K::Ts),
6313 ("deprecated", K::Bool),
6314 ("pendingDeletion", K::Bool),
6315 ],
6316 list_field: Some("mandatoryParameters"),
6317 list_elems: &[
6318 ("name", K::Str),
6319 ("type", K::Str),
6320 ("value", K::Struct),
6321 ("defaultValue", K::Struct),
6322 ("valueConditions", K::List),
6323 ("description", K::Str),
6324 ],
6325 list_scalar: false,
6326 req_payload: false,
6327 },
6328 OpMeta {
6329 op: "GetCommandExecution",
6330 method: "GET",
6331 segs: &[Seg::Fixed("command-executions"), Seg::Label("executionId")],
6332 verb: Verb::Get,
6333 rtype: "command-executions",
6334 nlabels: 1,
6335 has_input: true,
6336 errors: &[
6337 "InternalServerException",
6338 "ResourceNotFoundException",
6339 "ThrottlingException",
6340 "ValidationException",
6341 ],
6342 rules: &[
6343 Rule {
6344 wire: "executionId",
6345 src: Src::Label,
6346 req: true,
6347 kind: K::Str,
6348 min_len: Some(1),
6349 max_len: Some(64),
6350 min_val: None,
6351 max_val: None,
6352 enums: &[],
6353 },
6354 Rule {
6355 wire: "targetArn",
6356 src: Src::Query,
6357 req: true,
6358 kind: K::Str,
6359 min_len: Some(0),
6360 max_len: Some(2048),
6361 min_val: None,
6362 max_val: None,
6363 enums: &[],
6364 },
6365 ],
6366 omembers: &[
6367 ("executionId", K::Str),
6368 ("commandArn", K::Str),
6369 ("targetArn", K::Str),
6370 ("status", K::Str),
6371 ("statusReason", K::Struct),
6372 ("result", K::Map),
6373 ("parameters", K::Map),
6374 ("executionTimeoutSeconds", K::Int),
6375 ("createdAt", K::Ts),
6376 ("lastUpdatedAt", K::Ts),
6377 ("startedAt", K::Ts),
6378 ("completedAt", K::Ts),
6379 ("timeToLive", K::Ts),
6380 ],
6381 list_field: None,
6382 list_elems: &[],
6383 list_scalar: false,
6384 req_payload: false,
6385 },
6386 OpMeta {
6387 op: "GetEffectivePolicies",
6388 method: "POST",
6389 segs: &[Seg::Fixed("effective-policies")],
6390 verb: Verb::Action,
6391 rtype: "effective-policies",
6392 nlabels: 0,
6393 has_input: true,
6394 errors: &[
6395 "InternalFailureException",
6396 "InvalidRequestException",
6397 "LimitExceededException",
6398 "ResourceNotFoundException",
6399 "ServiceUnavailableException",
6400 "ThrottlingException",
6401 "UnauthorizedException",
6402 ],
6403 rules: &[Rule {
6404 wire: "thingName",
6405 src: Src::Query,
6406 req: false,
6407 kind: K::Str,
6408 min_len: Some(1),
6409 max_len: Some(128),
6410 min_val: None,
6411 max_val: None,
6412 enums: &[],
6413 }],
6414 omembers: &[("effectivePolicies", K::List)],
6415 list_field: Some("effectivePolicies"),
6416 list_elems: &[
6417 ("policyName", K::Str),
6418 ("policyArn", K::Str),
6419 ("policyDocument", K::Str),
6420 ],
6421 list_scalar: false,
6422 req_payload: false,
6423 },
6424 OpMeta {
6425 op: "GetIndexingConfiguration",
6426 method: "GET",
6427 segs: &[Seg::Fixed("indexing"), Seg::Fixed("config")],
6428 verb: Verb::Action,
6429 rtype: "indexing",
6430 nlabels: 0,
6431 has_input: true,
6432 errors: &[
6433 "InternalFailureException",
6434 "InvalidRequestException",
6435 "ServiceUnavailableException",
6436 "ThrottlingException",
6437 "UnauthorizedException",
6438 ],
6439 rules: &[],
6440 omembers: &[
6441 ("thingIndexingConfiguration", K::Struct),
6442 ("thingGroupIndexingConfiguration", K::Struct),
6443 ],
6444 list_field: None,
6445 list_elems: &[],
6446 list_scalar: false,
6447 req_payload: false,
6448 },
6449 OpMeta {
6450 op: "GetJobDocument",
6451 method: "GET",
6452 segs: &[
6453 Seg::Fixed("jobs"),
6454 Seg::Label("jobId"),
6455 Seg::Fixed("job-document"),
6456 ],
6457 verb: Verb::Action,
6458 rtype: "jobs",
6459 nlabels: 1,
6460 has_input: true,
6461 errors: &[
6462 "InvalidRequestException",
6463 "ResourceNotFoundException",
6464 "ServiceUnavailableException",
6465 "ThrottlingException",
6466 ],
6467 rules: &[Rule {
6468 wire: "jobId",
6469 src: Src::Label,
6470 req: true,
6471 kind: K::Str,
6472 min_len: Some(1),
6473 max_len: Some(64),
6474 min_val: None,
6475 max_val: None,
6476 enums: &[],
6477 }],
6478 omembers: &[("document", K::Str)],
6479 list_field: None,
6480 list_elems: &[],
6481 list_scalar: false,
6482 req_payload: false,
6483 },
6484 OpMeta {
6485 op: "GetLoggingOptions",
6486 method: "GET",
6487 segs: &[Seg::Fixed("loggingOptions")],
6488 verb: Verb::Action,
6489 rtype: "loggingOptions",
6490 nlabels: 0,
6491 has_input: true,
6492 errors: &[
6493 "InternalException",
6494 "InvalidRequestException",
6495 "ServiceUnavailableException",
6496 ],
6497 rules: &[],
6498 omembers: &[("roleArn", K::Str), ("logLevel", K::Str)],
6499 list_field: None,
6500 list_elems: &[],
6501 list_scalar: false,
6502 req_payload: false,
6503 },
6504 OpMeta {
6505 op: "GetOTAUpdate",
6506 method: "GET",
6507 segs: &[Seg::Fixed("otaUpdates"), Seg::Label("otaUpdateId")],
6508 verb: Verb::Get,
6509 rtype: "otaUpdates",
6510 nlabels: 1,
6511 has_input: true,
6512 errors: &[
6513 "InternalFailureException",
6514 "InvalidRequestException",
6515 "ResourceNotFoundException",
6516 "ServiceUnavailableException",
6517 "ThrottlingException",
6518 "UnauthorizedException",
6519 ],
6520 rules: &[Rule {
6521 wire: "otaUpdateId",
6522 src: Src::Label,
6523 req: true,
6524 kind: K::Str,
6525 min_len: Some(1),
6526 max_len: Some(128),
6527 min_val: None,
6528 max_val: None,
6529 enums: &[],
6530 }],
6531 omembers: &[("otaUpdateInfo", K::Struct)],
6532 list_field: None,
6533 list_elems: &[],
6534 list_scalar: false,
6535 req_payload: false,
6536 },
6537 OpMeta {
6538 op: "GetPackage",
6539 method: "GET",
6540 segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
6541 verb: Verb::Get,
6542 rtype: "packages",
6543 nlabels: 1,
6544 has_input: true,
6545 errors: &[
6546 "InternalServerException",
6547 "ResourceNotFoundException",
6548 "ThrottlingException",
6549 "ValidationException",
6550 ],
6551 rules: &[Rule {
6552 wire: "packageName",
6553 src: Src::Label,
6554 req: true,
6555 kind: K::Str,
6556 min_len: Some(1),
6557 max_len: Some(128),
6558 min_val: None,
6559 max_val: None,
6560 enums: &[],
6561 }],
6562 omembers: &[
6563 ("packageName", K::Str),
6564 ("packageArn", K::Str),
6565 ("description", K::Str),
6566 ("defaultVersionName", K::Str),
6567 ("creationDate", K::Ts),
6568 ("lastModifiedDate", K::Ts),
6569 ],
6570 list_field: None,
6571 list_elems: &[],
6572 list_scalar: false,
6573 req_payload: false,
6574 },
6575 OpMeta {
6576 op: "GetPackageConfiguration",
6577 method: "GET",
6578 segs: &[Seg::Fixed("package-configuration")],
6579 verb: Verb::Action,
6580 rtype: "package-configuration",
6581 nlabels: 0,
6582 has_input: true,
6583 errors: &["InternalServerException", "ThrottlingException"],
6584 rules: &[],
6585 omembers: &[("versionUpdateByJobsConfig", K::Struct)],
6586 list_field: None,
6587 list_elems: &[],
6588 list_scalar: false,
6589 req_payload: false,
6590 },
6591 OpMeta {
6592 op: "GetPackageVersion",
6593 method: "GET",
6594 segs: &[
6595 Seg::Fixed("packages"),
6596 Seg::Label("packageName"),
6597 Seg::Fixed("versions"),
6598 Seg::Label("versionName"),
6599 ],
6600 verb: Verb::Get,
6601 rtype: "packages",
6602 nlabels: 2,
6603 has_input: true,
6604 errors: &[
6605 "InternalServerException",
6606 "ResourceNotFoundException",
6607 "ThrottlingException",
6608 "ValidationException",
6609 ],
6610 rules: &[
6611 Rule {
6612 wire: "packageName",
6613 src: Src::Label,
6614 req: true,
6615 kind: K::Str,
6616 min_len: Some(1),
6617 max_len: Some(128),
6618 min_val: None,
6619 max_val: None,
6620 enums: &[],
6621 },
6622 Rule {
6623 wire: "versionName",
6624 src: Src::Label,
6625 req: true,
6626 kind: K::Str,
6627 min_len: Some(1),
6628 max_len: Some(64),
6629 min_val: None,
6630 max_val: None,
6631 enums: &[],
6632 },
6633 ],
6634 omembers: &[
6635 ("packageVersionArn", K::Str),
6636 ("packageName", K::Str),
6637 ("versionName", K::Str),
6638 ("description", K::Str),
6639 ("attributes", K::Map),
6640 ("artifact", K::Struct),
6641 ("status", K::Str),
6642 ("errorReason", K::Str),
6643 ("creationDate", K::Ts),
6644 ("lastModifiedDate", K::Ts),
6645 ("sbom", K::Struct),
6646 ("sbomValidationStatus", K::Str),
6647 ("recipe", K::Str),
6648 ],
6649 list_field: None,
6650 list_elems: &[],
6651 list_scalar: false,
6652 req_payload: false,
6653 },
6654 OpMeta {
6655 op: "GetPercentiles",
6656 method: "POST",
6657 segs: &[Seg::Fixed("indices"), Seg::Fixed("percentiles")],
6658 verb: Verb::Action,
6659 rtype: "indices",
6660 nlabels: 0,
6661 has_input: true,
6662 errors: &[
6663 "IndexNotReadyException",
6664 "InternalFailureException",
6665 "InvalidAggregationException",
6666 "InvalidQueryException",
6667 "InvalidRequestException",
6668 "ResourceNotFoundException",
6669 "ServiceUnavailableException",
6670 "ThrottlingException",
6671 "UnauthorizedException",
6672 ],
6673 rules: &[
6674 Rule {
6675 wire: "indexName",
6676 src: Src::Body,
6677 req: false,
6678 kind: K::Str,
6679 min_len: Some(1),
6680 max_len: Some(128),
6681 min_val: None,
6682 max_val: None,
6683 enums: &[],
6684 },
6685 Rule {
6686 wire: "queryString",
6687 src: Src::Body,
6688 req: true,
6689 kind: K::Str,
6690 min_len: Some(1),
6691 max_len: None,
6692 min_val: None,
6693 max_val: None,
6694 enums: &[],
6695 },
6696 Rule {
6697 wire: "aggregationField",
6698 src: Src::Body,
6699 req: false,
6700 kind: K::Str,
6701 min_len: Some(1),
6702 max_len: None,
6703 min_val: None,
6704 max_val: None,
6705 enums: &[],
6706 },
6707 ],
6708 omembers: &[("percentiles", K::List)],
6709 list_field: Some("percentiles"),
6710 list_elems: &[("percent", K::Num), ("value", K::Num)],
6711 list_scalar: false,
6712 req_payload: false,
6713 },
6714 OpMeta {
6715 op: "GetPolicy",
6716 method: "GET",
6717 segs: &[Seg::Fixed("policies"), Seg::Label("policyName")],
6718 verb: Verb::Get,
6719 rtype: "policies",
6720 nlabels: 1,
6721 has_input: true,
6722 errors: &[
6723 "InternalFailureException",
6724 "InvalidRequestException",
6725 "ResourceNotFoundException",
6726 "ServiceUnavailableException",
6727 "ThrottlingException",
6728 "UnauthorizedException",
6729 ],
6730 rules: &[Rule {
6731 wire: "policyName",
6732 src: Src::Label,
6733 req: true,
6734 kind: K::Str,
6735 min_len: Some(1),
6736 max_len: Some(128),
6737 min_val: None,
6738 max_val: None,
6739 enums: &[],
6740 }],
6741 omembers: &[
6742 ("policyName", K::Str),
6743 ("policyArn", K::Str),
6744 ("policyDocument", K::Str),
6745 ("defaultVersionId", K::Str),
6746 ("creationDate", K::Ts),
6747 ("lastModifiedDate", K::Ts),
6748 ("generationId", K::Str),
6749 ],
6750 list_field: None,
6751 list_elems: &[],
6752 list_scalar: false,
6753 req_payload: false,
6754 },
6755 OpMeta {
6756 op: "GetPolicyVersion",
6757 method: "GET",
6758 segs: &[
6759 Seg::Fixed("policies"),
6760 Seg::Label("policyName"),
6761 Seg::Fixed("version"),
6762 Seg::Label("policyVersionId"),
6763 ],
6764 verb: Verb::Get,
6765 rtype: "policies",
6766 nlabels: 2,
6767 has_input: true,
6768 errors: &[
6769 "InternalFailureException",
6770 "InvalidRequestException",
6771 "ResourceNotFoundException",
6772 "ServiceUnavailableException",
6773 "ThrottlingException",
6774 "UnauthorizedException",
6775 ],
6776 rules: &[
6777 Rule {
6778 wire: "policyName",
6779 src: Src::Label,
6780 req: true,
6781 kind: K::Str,
6782 min_len: Some(1),
6783 max_len: Some(128),
6784 min_val: None,
6785 max_val: None,
6786 enums: &[],
6787 },
6788 Rule {
6789 wire: "policyVersionId",
6790 src: Src::Label,
6791 req: true,
6792 kind: K::Str,
6793 min_len: None,
6794 max_len: None,
6795 min_val: None,
6796 max_val: None,
6797 enums: &[],
6798 },
6799 ],
6800 omembers: &[
6801 ("policyArn", K::Str),
6802 ("policyName", K::Str),
6803 ("policyDocument", K::Str),
6804 ("policyVersionId", K::Str),
6805 ("isDefaultVersion", K::Bool),
6806 ("creationDate", K::Ts),
6807 ("lastModifiedDate", K::Ts),
6808 ("generationId", K::Str),
6809 ],
6810 list_field: None,
6811 list_elems: &[],
6812 list_scalar: false,
6813 req_payload: false,
6814 },
6815 OpMeta {
6816 op: "GetRegistrationCode",
6817 method: "GET",
6818 segs: &[Seg::Fixed("registrationcode")],
6819 verb: Verb::Action,
6820 rtype: "registrationcode",
6821 nlabels: 0,
6822 has_input: true,
6823 errors: &[
6824 "InternalFailureException",
6825 "InvalidRequestException",
6826 "ServiceUnavailableException",
6827 "ThrottlingException",
6828 "UnauthorizedException",
6829 ],
6830 rules: &[],
6831 omembers: &[("registrationCode", K::Str)],
6832 list_field: None,
6833 list_elems: &[],
6834 list_scalar: false,
6835 req_payload: false,
6836 },
6837 OpMeta {
6838 op: "GetStatistics",
6839 method: "POST",
6840 segs: &[Seg::Fixed("indices"), Seg::Fixed("statistics")],
6841 verb: Verb::Action,
6842 rtype: "indices",
6843 nlabels: 0,
6844 has_input: true,
6845 errors: &[
6846 "IndexNotReadyException",
6847 "InternalFailureException",
6848 "InvalidAggregationException",
6849 "InvalidQueryException",
6850 "InvalidRequestException",
6851 "ResourceNotFoundException",
6852 "ServiceUnavailableException",
6853 "ThrottlingException",
6854 "UnauthorizedException",
6855 ],
6856 rules: &[
6857 Rule {
6858 wire: "indexName",
6859 src: Src::Body,
6860 req: false,
6861 kind: K::Str,
6862 min_len: Some(1),
6863 max_len: Some(128),
6864 min_val: None,
6865 max_val: None,
6866 enums: &[],
6867 },
6868 Rule {
6869 wire: "queryString",
6870 src: Src::Body,
6871 req: true,
6872 kind: K::Str,
6873 min_len: Some(1),
6874 max_len: None,
6875 min_val: None,
6876 max_val: None,
6877 enums: &[],
6878 },
6879 Rule {
6880 wire: "aggregationField",
6881 src: Src::Body,
6882 req: false,
6883 kind: K::Str,
6884 min_len: Some(1),
6885 max_len: None,
6886 min_val: None,
6887 max_val: None,
6888 enums: &[],
6889 },
6890 ],
6891 omembers: &[("statistics", K::Struct)],
6892 list_field: None,
6893 list_elems: &[],
6894 list_scalar: false,
6895 req_payload: false,
6896 },
6897 OpMeta {
6898 op: "GetThingConnectivityData",
6899 method: "POST",
6900 segs: &[
6901 Seg::Fixed("things"),
6902 Seg::Label("thingName"),
6903 Seg::Fixed("connectivity-data"),
6904 ],
6905 verb: Verb::Action,
6906 rtype: "things",
6907 nlabels: 1,
6908 has_input: true,
6909 errors: &[
6910 "IndexNotReadyException",
6911 "InternalFailureException",
6912 "InvalidRequestException",
6913 "ResourceNotFoundException",
6914 "ServiceUnavailableException",
6915 "ThrottlingException",
6916 "UnauthorizedException",
6917 ],
6918 rules: &[Rule {
6919 wire: "thingName",
6920 src: Src::Label,
6921 req: true,
6922 kind: K::Str,
6923 min_len: Some(1),
6924 max_len: Some(128),
6925 min_val: None,
6926 max_val: None,
6927 enums: &[],
6928 }],
6929 omembers: &[
6930 ("thingName", K::Str),
6931 ("connected", K::Bool),
6932 ("timestamp", K::Ts),
6933 ("disconnectReason", K::Str),
6934 ("sourceIp", K::Str),
6935 ("sourcePort", K::Int),
6936 ("targetIp", K::Str),
6937 ("targetPort", K::Int),
6938 ("vpcEndpointId", K::Str),
6939 ("keepAliveDuration", K::Int),
6940 ("cleanSession", K::Bool),
6941 ("sessionExpiry", K::Int),
6942 ("clientId", K::Str),
6943 ],
6944 list_field: None,
6945 list_elems: &[],
6946 list_scalar: false,
6947 req_payload: false,
6948 },
6949 OpMeta {
6950 op: "GetTopicRule",
6951 method: "GET",
6952 segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
6953 verb: Verb::Get,
6954 rtype: "rules",
6955 nlabels: 1,
6956 has_input: true,
6957 errors: &[
6958 "InternalException",
6959 "InvalidRequestException",
6960 "ServiceUnavailableException",
6961 "UnauthorizedException",
6962 ],
6963 rules: &[Rule {
6964 wire: "ruleName",
6965 src: Src::Label,
6966 req: true,
6967 kind: K::Str,
6968 min_len: Some(1),
6969 max_len: Some(128),
6970 min_val: None,
6971 max_val: None,
6972 enums: &[],
6973 }],
6974 omembers: &[("ruleArn", K::Str), ("rule", K::Struct)],
6975 list_field: None,
6976 list_elems: &[],
6977 list_scalar: false,
6978 req_payload: false,
6979 },
6980 OpMeta {
6981 op: "GetTopicRuleDestination",
6982 method: "GET",
6983 segs: &[Seg::Fixed("destinations"), Seg::Greedy("arn")],
6984 verb: Verb::Get,
6985 rtype: "destinations",
6986 nlabels: 1,
6987 has_input: true,
6988 errors: &[
6989 "InternalException",
6990 "InvalidRequestException",
6991 "ServiceUnavailableException",
6992 "UnauthorizedException",
6993 ],
6994 rules: &[Rule {
6995 wire: "arn",
6996 src: Src::Label,
6997 req: true,
6998 kind: K::Str,
6999 min_len: None,
7000 max_len: None,
7001 min_val: None,
7002 max_val: None,
7003 enums: &[],
7004 }],
7005 omembers: &[("topicRuleDestination", K::Struct)],
7006 list_field: None,
7007 list_elems: &[],
7008 list_scalar: false,
7009 req_payload: false,
7010 },
7011 OpMeta {
7012 op: "GetV2LoggingOptions",
7013 method: "GET",
7014 segs: &[Seg::Fixed("v2LoggingOptions")],
7015 verb: Verb::Action,
7016 rtype: "v2LoggingOptions",
7017 nlabels: 0,
7018 has_input: true,
7019 errors: &[
7020 "InternalException",
7021 "NotConfiguredException",
7022 "ServiceUnavailableException",
7023 ],
7024 rules: &[],
7025 omembers: &[
7026 ("roleArn", K::Str),
7027 ("defaultLogLevel", K::Str),
7028 ("disableAllLogs", K::Bool),
7029 ("eventConfigurations", K::List),
7030 ],
7031 list_field: Some("eventConfigurations"),
7032 list_elems: &[
7033 ("eventType", K::Str),
7034 ("logLevel", K::Str),
7035 ("logDestination", K::Str),
7036 ],
7037 list_scalar: false,
7038 req_payload: false,
7039 },
7040 OpMeta {
7041 op: "ListActiveViolations",
7042 method: "GET",
7043 segs: &[Seg::Fixed("active-violations")],
7044 verb: Verb::List,
7045 rtype: "active-violations",
7046 nlabels: 0,
7047 has_input: true,
7048 errors: &[
7049 "InternalFailureException",
7050 "InvalidRequestException",
7051 "ResourceNotFoundException",
7052 "ThrottlingException",
7053 ],
7054 rules: &[
7055 Rule {
7056 wire: "thingName",
7057 src: Src::Query,
7058 req: false,
7059 kind: K::Str,
7060 min_len: Some(1),
7061 max_len: Some(128),
7062 min_val: None,
7063 max_val: None,
7064 enums: &[],
7065 },
7066 Rule {
7067 wire: "securityProfileName",
7068 src: Src::Query,
7069 req: false,
7070 kind: K::Str,
7071 min_len: Some(1),
7072 max_len: Some(128),
7073 min_val: None,
7074 max_val: None,
7075 enums: &[],
7076 },
7077 Rule {
7078 wire: "behaviorCriteriaType",
7079 src: Src::Query,
7080 req: false,
7081 kind: K::Str,
7082 min_len: None,
7083 max_len: None,
7084 min_val: None,
7085 max_val: None,
7086 enums: &["STATIC", "STATISTICAL", "MACHINE_LEARNING"],
7087 },
7088 Rule {
7089 wire: "verificationState",
7090 src: Src::Query,
7091 req: false,
7092 kind: K::Str,
7093 min_len: None,
7094 max_len: None,
7095 min_val: None,
7096 max_val: None,
7097 enums: &[
7098 "FALSE_POSITIVE",
7099 "BENIGN_POSITIVE",
7100 "TRUE_POSITIVE",
7101 "UNKNOWN",
7102 ],
7103 },
7104 Rule {
7105 wire: "maxResults",
7106 src: Src::Query,
7107 req: false,
7108 kind: K::Int,
7109 min_len: None,
7110 max_len: None,
7111 min_val: Some(1),
7112 max_val: Some(250),
7113 enums: &[],
7114 },
7115 ],
7116 omembers: &[("activeViolations", K::List), ("nextToken", K::Str)],
7117 list_field: Some("activeViolations"),
7118 list_elems: &[
7119 ("violationId", K::Str),
7120 ("thingName", K::Str),
7121 ("securityProfileName", K::Str),
7122 ("behavior", K::Struct),
7123 ("lastViolationValue", K::Struct),
7124 ("violationEventAdditionalInfo", K::Struct),
7125 ("verificationState", K::Str),
7126 ("verificationStateDescription", K::Str),
7127 ("lastViolationTime", K::Ts),
7128 ("violationStartTime", K::Ts),
7129 ],
7130 list_scalar: false,
7131 req_payload: false,
7132 },
7133 OpMeta {
7134 op: "ListAttachedPolicies",
7135 method: "POST",
7136 segs: &[Seg::Fixed("attached-policies"), Seg::Label("target")],
7137 verb: Verb::List,
7138 rtype: "attached-policies",
7139 nlabels: 1,
7140 has_input: true,
7141 errors: &[
7142 "InternalFailureException",
7143 "InvalidRequestException",
7144 "LimitExceededException",
7145 "ResourceNotFoundException",
7146 "ServiceUnavailableException",
7147 "ThrottlingException",
7148 "UnauthorizedException",
7149 ],
7150 rules: &[
7151 Rule {
7152 wire: "target",
7153 src: Src::Label,
7154 req: true,
7155 kind: K::Str,
7156 min_len: None,
7157 max_len: None,
7158 min_val: None,
7159 max_val: None,
7160 enums: &[],
7161 },
7162 Rule {
7163 wire: "marker",
7164 src: Src::Query,
7165 req: false,
7166 kind: K::Str,
7167 min_len: Some(0),
7168 max_len: Some(1024),
7169 min_val: None,
7170 max_val: None,
7171 enums: &[],
7172 },
7173 Rule {
7174 wire: "pageSize",
7175 src: Src::Query,
7176 req: false,
7177 kind: K::Int,
7178 min_len: None,
7179 max_len: None,
7180 min_val: Some(1),
7181 max_val: Some(250),
7182 enums: &[],
7183 },
7184 ],
7185 omembers: &[("policies", K::List), ("nextMarker", K::Str)],
7186 list_field: Some("policies"),
7187 list_elems: &[("policyName", K::Str), ("policyArn", K::Str)],
7188 list_scalar: false,
7189 req_payload: false,
7190 },
7191 OpMeta {
7192 op: "ListAuditFindings",
7193 method: "POST",
7194 segs: &[Seg::Fixed("audit"), Seg::Fixed("findings")],
7195 verb: Verb::List,
7196 rtype: "audit",
7197 nlabels: 0,
7198 has_input: true,
7199 errors: &[
7200 "InternalFailureException",
7201 "InvalidRequestException",
7202 "ThrottlingException",
7203 ],
7204 rules: &[
7205 Rule {
7206 wire: "taskId",
7207 src: Src::Body,
7208 req: false,
7209 kind: K::Str,
7210 min_len: Some(1),
7211 max_len: Some(40),
7212 min_val: None,
7213 max_val: None,
7214 enums: &[],
7215 },
7216 Rule {
7217 wire: "maxResults",
7218 src: Src::Body,
7219 req: false,
7220 kind: K::Int,
7221 min_len: None,
7222 max_len: None,
7223 min_val: Some(1),
7224 max_val: Some(250),
7225 enums: &[],
7226 },
7227 ],
7228 omembers: &[("findings", K::List), ("nextToken", K::Str)],
7229 list_field: Some("findings"),
7230 list_elems: &[
7231 ("findingId", K::Str),
7232 ("taskId", K::Str),
7233 ("checkName", K::Str),
7234 ("taskStartTime", K::Ts),
7235 ("findingTime", K::Ts),
7236 ("severity", K::Str),
7237 ("nonCompliantResource", K::Struct),
7238 ("relatedResources", K::List),
7239 ("reasonForNonCompliance", K::Str),
7240 ("reasonForNonComplianceCode", K::Str),
7241 ("isSuppressed", K::Bool),
7242 ],
7243 list_scalar: false,
7244 req_payload: false,
7245 },
7246 OpMeta {
7247 op: "ListAuditMitigationActionsExecutions",
7248 method: "GET",
7249 segs: &[
7250 Seg::Fixed("audit"),
7251 Seg::Fixed("mitigationactions"),
7252 Seg::Fixed("executions"),
7253 ],
7254 verb: Verb::List,
7255 rtype: "audit",
7256 nlabels: 0,
7257 has_input: true,
7258 errors: &[
7259 "InternalFailureException",
7260 "InvalidRequestException",
7261 "ThrottlingException",
7262 ],
7263 rules: &[
7264 Rule {
7265 wire: "taskId",
7266 src: Src::Query,
7267 req: true,
7268 kind: K::Str,
7269 min_len: Some(1),
7270 max_len: Some(128),
7271 min_val: None,
7272 max_val: None,
7273 enums: &[],
7274 },
7275 Rule {
7276 wire: "actionStatus",
7277 src: Src::Query,
7278 req: false,
7279 kind: K::Str,
7280 min_len: None,
7281 max_len: None,
7282 min_val: None,
7283 max_val: None,
7284 enums: &[
7285 "IN_PROGRESS",
7286 "COMPLETED",
7287 "FAILED",
7288 "CANCELED",
7289 "SKIPPED",
7290 "PENDING",
7291 ],
7292 },
7293 Rule {
7294 wire: "findingId",
7295 src: Src::Query,
7296 req: true,
7297 kind: K::Str,
7298 min_len: Some(1),
7299 max_len: Some(128),
7300 min_val: None,
7301 max_val: None,
7302 enums: &[],
7303 },
7304 Rule {
7305 wire: "maxResults",
7306 src: Src::Query,
7307 req: false,
7308 kind: K::Int,
7309 min_len: None,
7310 max_len: None,
7311 min_val: Some(1),
7312 max_val: Some(250),
7313 enums: &[],
7314 },
7315 ],
7316 omembers: &[("actionsExecutions", K::List), ("nextToken", K::Str)],
7317 list_field: Some("actionsExecutions"),
7318 list_elems: &[
7319 ("taskId", K::Str),
7320 ("findingId", K::Str),
7321 ("actionName", K::Str),
7322 ("actionId", K::Str),
7323 ("status", K::Str),
7324 ("startTime", K::Ts),
7325 ("endTime", K::Ts),
7326 ("errorCode", K::Str),
7327 ("message", K::Str),
7328 ],
7329 list_scalar: false,
7330 req_payload: false,
7331 },
7332 OpMeta {
7333 op: "ListAuditMitigationActionsTasks",
7334 method: "GET",
7335 segs: &[
7336 Seg::Fixed("audit"),
7337 Seg::Fixed("mitigationactions"),
7338 Seg::Fixed("tasks"),
7339 ],
7340 verb: Verb::List,
7341 rtype: "audit",
7342 nlabels: 0,
7343 has_input: true,
7344 errors: &[
7345 "InternalFailureException",
7346 "InvalidRequestException",
7347 "ThrottlingException",
7348 ],
7349 rules: &[
7350 Rule {
7351 wire: "auditTaskId",
7352 src: Src::Query,
7353 req: false,
7354 kind: K::Str,
7355 min_len: Some(1),
7356 max_len: Some(40),
7357 min_val: None,
7358 max_val: None,
7359 enums: &[],
7360 },
7361 Rule {
7362 wire: "findingId",
7363 src: Src::Query,
7364 req: false,
7365 kind: K::Str,
7366 min_len: Some(1),
7367 max_len: Some(128),
7368 min_val: None,
7369 max_val: None,
7370 enums: &[],
7371 },
7372 Rule {
7373 wire: "taskStatus",
7374 src: Src::Query,
7375 req: false,
7376 kind: K::Str,
7377 min_len: None,
7378 max_len: None,
7379 min_val: None,
7380 max_val: None,
7381 enums: &["IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"],
7382 },
7383 Rule {
7384 wire: "maxResults",
7385 src: Src::Query,
7386 req: false,
7387 kind: K::Int,
7388 min_len: None,
7389 max_len: None,
7390 min_val: Some(1),
7391 max_val: Some(250),
7392 enums: &[],
7393 },
7394 Rule {
7395 wire: "startTime",
7396 src: Src::Query,
7397 req: true,
7398 kind: K::Ts,
7399 min_len: None,
7400 max_len: None,
7401 min_val: None,
7402 max_val: None,
7403 enums: &[],
7404 },
7405 Rule {
7406 wire: "endTime",
7407 src: Src::Query,
7408 req: true,
7409 kind: K::Ts,
7410 min_len: None,
7411 max_len: None,
7412 min_val: None,
7413 max_val: None,
7414 enums: &[],
7415 },
7416 ],
7417 omembers: &[("tasks", K::List), ("nextToken", K::Str)],
7418 list_field: Some("tasks"),
7419 list_elems: &[
7420 ("taskId", K::Str),
7421 ("startTime", K::Ts),
7422 ("taskStatus", K::Str),
7423 ],
7424 list_scalar: false,
7425 req_payload: false,
7426 },
7427 OpMeta {
7428 op: "ListAuditSuppressions",
7429 method: "POST",
7430 segs: &[
7431 Seg::Fixed("audit"),
7432 Seg::Fixed("suppressions"),
7433 Seg::Fixed("list"),
7434 ],
7435 verb: Verb::List,
7436 rtype: "audit",
7437 nlabels: 0,
7438 has_input: true,
7439 errors: &[
7440 "InternalFailureException",
7441 "InvalidRequestException",
7442 "ThrottlingException",
7443 ],
7444 rules: &[Rule {
7445 wire: "maxResults",
7446 src: Src::Body,
7447 req: false,
7448 kind: K::Int,
7449 min_len: None,
7450 max_len: None,
7451 min_val: Some(1),
7452 max_val: Some(250),
7453 enums: &[],
7454 }],
7455 omembers: &[("suppressions", K::List), ("nextToken", K::Str)],
7456 list_field: Some("suppressions"),
7457 list_elems: &[
7458 ("checkName", K::Str),
7459 ("resourceIdentifier", K::Struct),
7460 ("expirationDate", K::Ts),
7461 ("suppressIndefinitely", K::Bool),
7462 ("description", K::Str),
7463 ],
7464 list_scalar: false,
7465 req_payload: false,
7466 },
7467 OpMeta {
7468 op: "ListAuditTasks",
7469 method: "GET",
7470 segs: &[Seg::Fixed("audit"), Seg::Fixed("tasks")],
7471 verb: Verb::List,
7472 rtype: "audit",
7473 nlabels: 0,
7474 has_input: true,
7475 errors: &[
7476 "InternalFailureException",
7477 "InvalidRequestException",
7478 "ThrottlingException",
7479 ],
7480 rules: &[
7481 Rule {
7482 wire: "startTime",
7483 src: Src::Query,
7484 req: true,
7485 kind: K::Ts,
7486 min_len: None,
7487 max_len: None,
7488 min_val: None,
7489 max_val: None,
7490 enums: &[],
7491 },
7492 Rule {
7493 wire: "endTime",
7494 src: Src::Query,
7495 req: true,
7496 kind: K::Ts,
7497 min_len: None,
7498 max_len: None,
7499 min_val: None,
7500 max_val: None,
7501 enums: &[],
7502 },
7503 Rule {
7504 wire: "taskType",
7505 src: Src::Query,
7506 req: false,
7507 kind: K::Str,
7508 min_len: None,
7509 max_len: None,
7510 min_val: None,
7511 max_val: None,
7512 enums: &["ON_DEMAND_AUDIT_TASK", "SCHEDULED_AUDIT_TASK"],
7513 },
7514 Rule {
7515 wire: "taskStatus",
7516 src: Src::Query,
7517 req: false,
7518 kind: K::Str,
7519 min_len: None,
7520 max_len: None,
7521 min_val: None,
7522 max_val: None,
7523 enums: &["IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"],
7524 },
7525 Rule {
7526 wire: "maxResults",
7527 src: Src::Query,
7528 req: false,
7529 kind: K::Int,
7530 min_len: None,
7531 max_len: None,
7532 min_val: Some(1),
7533 max_val: Some(250),
7534 enums: &[],
7535 },
7536 ],
7537 omembers: &[("tasks", K::List), ("nextToken", K::Str)],
7538 list_field: Some("tasks"),
7539 list_elems: &[
7540 ("taskId", K::Str),
7541 ("taskStatus", K::Str),
7542 ("taskType", K::Str),
7543 ],
7544 list_scalar: false,
7545 req_payload: false,
7546 },
7547 OpMeta {
7548 op: "ListAuthorizers",
7549 method: "GET",
7550 segs: &[Seg::Fixed("authorizers")],
7551 verb: Verb::List,
7552 rtype: "authorizers",
7553 nlabels: 0,
7554 has_input: true,
7555 errors: &[
7556 "InternalFailureException",
7557 "InvalidRequestException",
7558 "ServiceUnavailableException",
7559 "ThrottlingException",
7560 "UnauthorizedException",
7561 ],
7562 rules: &[
7563 Rule {
7564 wire: "pageSize",
7565 src: Src::Query,
7566 req: false,
7567 kind: K::Int,
7568 min_len: None,
7569 max_len: None,
7570 min_val: Some(1),
7571 max_val: Some(250),
7572 enums: &[],
7573 },
7574 Rule {
7575 wire: "marker",
7576 src: Src::Query,
7577 req: false,
7578 kind: K::Str,
7579 min_len: Some(0),
7580 max_len: Some(1024),
7581 min_val: None,
7582 max_val: None,
7583 enums: &[],
7584 },
7585 Rule {
7586 wire: "status",
7587 src: Src::Query,
7588 req: false,
7589 kind: K::Str,
7590 min_len: None,
7591 max_len: None,
7592 min_val: None,
7593 max_val: None,
7594 enums: &["ACTIVE", "INACTIVE"],
7595 },
7596 ],
7597 omembers: &[("authorizers", K::List), ("nextMarker", K::Str)],
7598 list_field: Some("authorizers"),
7599 list_elems: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
7600 list_scalar: false,
7601 req_payload: false,
7602 },
7603 OpMeta {
7604 op: "ListBillingGroups",
7605 method: "GET",
7606 segs: &[Seg::Fixed("billing-groups")],
7607 verb: Verb::List,
7608 rtype: "billing-groups",
7609 nlabels: 0,
7610 has_input: true,
7611 errors: &[
7612 "InternalFailureException",
7613 "InvalidRequestException",
7614 "ResourceNotFoundException",
7615 "ThrottlingException",
7616 ],
7617 rules: &[
7618 Rule {
7619 wire: "maxResults",
7620 src: Src::Query,
7621 req: false,
7622 kind: K::Int,
7623 min_len: None,
7624 max_len: None,
7625 min_val: Some(1),
7626 max_val: Some(250),
7627 enums: &[],
7628 },
7629 Rule {
7630 wire: "namePrefixFilter",
7631 src: Src::Query,
7632 req: false,
7633 kind: K::Str,
7634 min_len: Some(1),
7635 max_len: Some(128),
7636 min_val: None,
7637 max_val: None,
7638 enums: &[],
7639 },
7640 ],
7641 omembers: &[("billingGroups", K::List), ("nextToken", K::Str)],
7642 list_field: Some("billingGroups"),
7643 list_elems: &[("groupName", K::Str), ("groupArn", K::Str)],
7644 list_scalar: false,
7645 req_payload: false,
7646 },
7647 OpMeta {
7648 op: "ListCACertificates",
7649 method: "GET",
7650 segs: &[Seg::Fixed("cacertificates")],
7651 verb: Verb::List,
7652 rtype: "cacertificates",
7653 nlabels: 0,
7654 has_input: true,
7655 errors: &[
7656 "InternalFailureException",
7657 "InvalidRequestException",
7658 "ServiceUnavailableException",
7659 "ThrottlingException",
7660 "UnauthorizedException",
7661 ],
7662 rules: &[
7663 Rule {
7664 wire: "pageSize",
7665 src: Src::Query,
7666 req: false,
7667 kind: K::Int,
7668 min_len: None,
7669 max_len: None,
7670 min_val: Some(1),
7671 max_val: Some(250),
7672 enums: &[],
7673 },
7674 Rule {
7675 wire: "marker",
7676 src: Src::Query,
7677 req: false,
7678 kind: K::Str,
7679 min_len: Some(0),
7680 max_len: Some(1024),
7681 min_val: None,
7682 max_val: None,
7683 enums: &[],
7684 },
7685 Rule {
7686 wire: "templateName",
7687 src: Src::Query,
7688 req: false,
7689 kind: K::Str,
7690 min_len: Some(1),
7691 max_len: Some(36),
7692 min_val: None,
7693 max_val: None,
7694 enums: &[],
7695 },
7696 ],
7697 omembers: &[("certificates", K::List), ("nextMarker", K::Str)],
7698 list_field: Some("certificates"),
7699 list_elems: &[
7700 ("certificateArn", K::Str),
7701 ("certificateId", K::Str),
7702 ("status", K::Str),
7703 ("creationDate", K::Ts),
7704 ],
7705 list_scalar: false,
7706 req_payload: false,
7707 },
7708 OpMeta {
7709 op: "ListCertificateProviders",
7710 method: "GET",
7711 segs: &[Seg::Fixed("certificate-providers")],
7712 verb: Verb::List,
7713 rtype: "certificate-providers",
7714 nlabels: 0,
7715 has_input: true,
7716 errors: &[
7717 "InternalFailureException",
7718 "InvalidRequestException",
7719 "ServiceUnavailableException",
7720 "ThrottlingException",
7721 "UnauthorizedException",
7722 ],
7723 rules: &[Rule {
7724 wire: "nextToken",
7725 src: Src::Query,
7726 req: false,
7727 kind: K::Str,
7728 min_len: Some(0),
7729 max_len: Some(1024),
7730 min_val: None,
7731 max_val: None,
7732 enums: &[],
7733 }],
7734 omembers: &[("certificateProviders", K::List), ("nextToken", K::Str)],
7735 list_field: Some("certificateProviders"),
7736 list_elems: &[
7737 ("certificateProviderName", K::Str),
7738 ("certificateProviderArn", K::Str),
7739 ],
7740 list_scalar: false,
7741 req_payload: false,
7742 },
7743 OpMeta {
7744 op: "ListCertificates",
7745 method: "GET",
7746 segs: &[Seg::Fixed("certificates")],
7747 verb: Verb::List,
7748 rtype: "certificates",
7749 nlabels: 0,
7750 has_input: true,
7751 errors: &[
7752 "InternalFailureException",
7753 "InvalidRequestException",
7754 "ServiceUnavailableException",
7755 "ThrottlingException",
7756 "UnauthorizedException",
7757 ],
7758 rules: &[
7759 Rule {
7760 wire: "pageSize",
7761 src: Src::Query,
7762 req: false,
7763 kind: K::Int,
7764 min_len: None,
7765 max_len: None,
7766 min_val: Some(1),
7767 max_val: Some(250),
7768 enums: &[],
7769 },
7770 Rule {
7771 wire: "marker",
7772 src: Src::Query,
7773 req: false,
7774 kind: K::Str,
7775 min_len: Some(0),
7776 max_len: Some(1024),
7777 min_val: None,
7778 max_val: None,
7779 enums: &[],
7780 },
7781 ],
7782 omembers: &[("certificates", K::List), ("nextMarker", K::Str)],
7783 list_field: Some("certificates"),
7784 list_elems: &[
7785 ("certificateArn", K::Str),
7786 ("certificateId", K::Str),
7787 ("status", K::Str),
7788 ("certificateMode", K::Str),
7789 ("creationDate", K::Ts),
7790 ],
7791 list_scalar: false,
7792 req_payload: false,
7793 },
7794 OpMeta {
7795 op: "ListCertificatesByCA",
7796 method: "GET",
7797 segs: &[
7798 Seg::Fixed("certificates-by-ca"),
7799 Seg::Label("caCertificateId"),
7800 ],
7801 verb: Verb::List,
7802 rtype: "certificates-by-ca",
7803 nlabels: 1,
7804 has_input: true,
7805 errors: &[
7806 "InternalFailureException",
7807 "InvalidRequestException",
7808 "ServiceUnavailableException",
7809 "ThrottlingException",
7810 "UnauthorizedException",
7811 ],
7812 rules: &[
7813 Rule {
7814 wire: "caCertificateId",
7815 src: Src::Label,
7816 req: true,
7817 kind: K::Str,
7818 min_len: Some(64),
7819 max_len: Some(64),
7820 min_val: None,
7821 max_val: None,
7822 enums: &[],
7823 },
7824 Rule {
7825 wire: "pageSize",
7826 src: Src::Query,
7827 req: false,
7828 kind: K::Int,
7829 min_len: None,
7830 max_len: None,
7831 min_val: Some(1),
7832 max_val: Some(250),
7833 enums: &[],
7834 },
7835 Rule {
7836 wire: "marker",
7837 src: Src::Query,
7838 req: false,
7839 kind: K::Str,
7840 min_len: Some(0),
7841 max_len: Some(1024),
7842 min_val: None,
7843 max_val: None,
7844 enums: &[],
7845 },
7846 ],
7847 omembers: &[("certificates", K::List), ("nextMarker", K::Str)],
7848 list_field: Some("certificates"),
7849 list_elems: &[
7850 ("certificateArn", K::Str),
7851 ("certificateId", K::Str),
7852 ("status", K::Str),
7853 ("certificateMode", K::Str),
7854 ("creationDate", K::Ts),
7855 ],
7856 list_scalar: false,
7857 req_payload: false,
7858 },
7859 OpMeta {
7860 op: "ListCommandExecutions",
7861 method: "POST",
7862 segs: &[Seg::Fixed("command-executions")],
7863 verb: Verb::List,
7864 rtype: "command-executions",
7865 nlabels: 0,
7866 has_input: true,
7867 errors: &[
7868 "InternalServerException",
7869 "ResourceNotFoundException",
7870 "ThrottlingException",
7871 "ValidationException",
7872 ],
7873 rules: &[
7874 Rule {
7875 wire: "maxResults",
7876 src: Src::Query,
7877 req: false,
7878 kind: K::Int,
7879 min_len: None,
7880 max_len: None,
7881 min_val: Some(1),
7882 max_val: Some(100),
7883 enums: &[],
7884 },
7885 Rule {
7886 wire: "namespace",
7887 src: Src::Body,
7888 req: false,
7889 kind: K::Str,
7890 min_len: None,
7891 max_len: None,
7892 min_val: None,
7893 max_val: None,
7894 enums: &["AWS-IoT", "AWS-IoT-FleetWise"],
7895 },
7896 Rule {
7897 wire: "status",
7898 src: Src::Body,
7899 req: false,
7900 kind: K::Str,
7901 min_len: None,
7902 max_len: None,
7903 min_val: None,
7904 max_val: None,
7905 enums: &[
7906 "CREATED",
7907 "IN_PROGRESS",
7908 "SUCCEEDED",
7909 "FAILED",
7910 "REJECTED",
7911 "TIMED_OUT",
7912 ],
7913 },
7914 Rule {
7915 wire: "sortOrder",
7916 src: Src::Body,
7917 req: false,
7918 kind: K::Str,
7919 min_len: None,
7920 max_len: None,
7921 min_val: None,
7922 max_val: None,
7923 enums: &["ASCENDING", "DESCENDING"],
7924 },
7925 Rule {
7926 wire: "targetArn",
7927 src: Src::Body,
7928 req: false,
7929 kind: K::Str,
7930 min_len: Some(0),
7931 max_len: Some(2048),
7932 min_val: None,
7933 max_val: None,
7934 enums: &[],
7935 },
7936 ],
7937 omembers: &[("commandExecutions", K::List), ("nextToken", K::Str)],
7938 list_field: Some("commandExecutions"),
7939 list_elems: &[
7940 ("commandArn", K::Str),
7941 ("executionId", K::Str),
7942 ("targetArn", K::Str),
7943 ("status", K::Str),
7944 ("createdAt", K::Ts),
7945 ("startedAt", K::Ts),
7946 ("completedAt", K::Ts),
7947 ],
7948 list_scalar: false,
7949 req_payload: false,
7950 },
7951 OpMeta {
7952 op: "ListCommands",
7953 method: "GET",
7954 segs: &[Seg::Fixed("commands")],
7955 verb: Verb::List,
7956 rtype: "commands",
7957 nlabels: 0,
7958 has_input: true,
7959 errors: &[
7960 "InternalServerException",
7961 "ThrottlingException",
7962 "ValidationException",
7963 ],
7964 rules: &[
7965 Rule {
7966 wire: "maxResults",
7967 src: Src::Query,
7968 req: false,
7969 kind: K::Int,
7970 min_len: None,
7971 max_len: None,
7972 min_val: Some(1),
7973 max_val: Some(100),
7974 enums: &[],
7975 },
7976 Rule {
7977 wire: "namespace",
7978 src: Src::Query,
7979 req: false,
7980 kind: K::Str,
7981 min_len: None,
7982 max_len: None,
7983 min_val: None,
7984 max_val: None,
7985 enums: &["AWS-IoT", "AWS-IoT-FleetWise"],
7986 },
7987 Rule {
7988 wire: "commandParameterName",
7989 src: Src::Query,
7990 req: false,
7991 kind: K::Str,
7992 min_len: Some(1),
7993 max_len: Some(192),
7994 min_val: None,
7995 max_val: None,
7996 enums: &[],
7997 },
7998 Rule {
7999 wire: "sortOrder",
8000 src: Src::Query,
8001 req: false,
8002 kind: K::Str,
8003 min_len: None,
8004 max_len: None,
8005 min_val: None,
8006 max_val: None,
8007 enums: &["ASCENDING", "DESCENDING"],
8008 },
8009 ],
8010 omembers: &[("commands", K::List), ("nextToken", K::Str)],
8011 list_field: Some("commands"),
8012 list_elems: &[
8013 ("commandArn", K::Str),
8014 ("commandId", K::Str),
8015 ("displayName", K::Str),
8016 ("deprecated", K::Bool),
8017 ("createdAt", K::Ts),
8018 ("lastUpdatedAt", K::Ts),
8019 ("pendingDeletion", K::Bool),
8020 ],
8021 list_scalar: false,
8022 req_payload: false,
8023 },
8024 OpMeta {
8025 op: "ListCustomMetrics",
8026 method: "GET",
8027 segs: &[Seg::Fixed("custom-metrics")],
8028 verb: Verb::List,
8029 rtype: "custom-metrics",
8030 nlabels: 0,
8031 has_input: true,
8032 errors: &[
8033 "InternalFailureException",
8034 "InvalidRequestException",
8035 "ThrottlingException",
8036 ],
8037 rules: &[Rule {
8038 wire: "maxResults",
8039 src: Src::Query,
8040 req: false,
8041 kind: K::Int,
8042 min_len: None,
8043 max_len: None,
8044 min_val: Some(1),
8045 max_val: Some(250),
8046 enums: &[],
8047 }],
8048 omembers: &[("metricNames", K::List), ("nextToken", K::Str)],
8049 list_field: Some("metricNames"),
8050 list_elems: &[],
8051 list_scalar: true,
8052 req_payload: false,
8053 },
8054 OpMeta {
8055 op: "ListDetectMitigationActionsExecutions",
8056 method: "GET",
8057 segs: &[
8058 Seg::Fixed("detect"),
8059 Seg::Fixed("mitigationactions"),
8060 Seg::Fixed("executions"),
8061 ],
8062 verb: Verb::List,
8063 rtype: "detect",
8064 nlabels: 0,
8065 has_input: true,
8066 errors: &[
8067 "InternalFailureException",
8068 "InvalidRequestException",
8069 "ThrottlingException",
8070 ],
8071 rules: &[
8072 Rule {
8073 wire: "taskId",
8074 src: Src::Query,
8075 req: false,
8076 kind: K::Str,
8077 min_len: Some(1),
8078 max_len: Some(128),
8079 min_val: None,
8080 max_val: None,
8081 enums: &[],
8082 },
8083 Rule {
8084 wire: "violationId",
8085 src: Src::Query,
8086 req: false,
8087 kind: K::Str,
8088 min_len: Some(1),
8089 max_len: Some(128),
8090 min_val: None,
8091 max_val: None,
8092 enums: &[],
8093 },
8094 Rule {
8095 wire: "thingName",
8096 src: Src::Query,
8097 req: false,
8098 kind: K::Str,
8099 min_len: Some(1),
8100 max_len: Some(128),
8101 min_val: None,
8102 max_val: None,
8103 enums: &[],
8104 },
8105 Rule {
8106 wire: "maxResults",
8107 src: Src::Query,
8108 req: false,
8109 kind: K::Int,
8110 min_len: None,
8111 max_len: None,
8112 min_val: Some(1),
8113 max_val: Some(250),
8114 enums: &[],
8115 },
8116 ],
8117 omembers: &[("actionsExecutions", K::List), ("nextToken", K::Str)],
8118 list_field: Some("actionsExecutions"),
8119 list_elems: &[
8120 ("taskId", K::Str),
8121 ("violationId", K::Str),
8122 ("actionName", K::Str),
8123 ("thingName", K::Str),
8124 ("executionStartDate", K::Ts),
8125 ("executionEndDate", K::Ts),
8126 ("status", K::Str),
8127 ("errorCode", K::Str),
8128 ("message", K::Str),
8129 ],
8130 list_scalar: false,
8131 req_payload: false,
8132 },
8133 OpMeta {
8134 op: "ListDetectMitigationActionsTasks",
8135 method: "GET",
8136 segs: &[
8137 Seg::Fixed("detect"),
8138 Seg::Fixed("mitigationactions"),
8139 Seg::Fixed("tasks"),
8140 ],
8141 verb: Verb::List,
8142 rtype: "detect",
8143 nlabels: 0,
8144 has_input: true,
8145 errors: &[
8146 "InternalFailureException",
8147 "InvalidRequestException",
8148 "ThrottlingException",
8149 ],
8150 rules: &[
8151 Rule {
8152 wire: "maxResults",
8153 src: Src::Query,
8154 req: false,
8155 kind: K::Int,
8156 min_len: None,
8157 max_len: None,
8158 min_val: Some(1),
8159 max_val: Some(250),
8160 enums: &[],
8161 },
8162 Rule {
8163 wire: "startTime",
8164 src: Src::Query,
8165 req: true,
8166 kind: K::Ts,
8167 min_len: None,
8168 max_len: None,
8169 min_val: None,
8170 max_val: None,
8171 enums: &[],
8172 },
8173 Rule {
8174 wire: "endTime",
8175 src: Src::Query,
8176 req: true,
8177 kind: K::Ts,
8178 min_len: None,
8179 max_len: None,
8180 min_val: None,
8181 max_val: None,
8182 enums: &[],
8183 },
8184 ],
8185 omembers: &[("tasks", K::List), ("nextToken", K::Str)],
8186 list_field: Some("tasks"),
8187 list_elems: &[
8188 ("taskId", K::Str),
8189 ("taskStatus", K::Str),
8190 ("taskStartTime", K::Ts),
8191 ("taskEndTime", K::Ts),
8192 ("target", K::Struct),
8193 ("violationEventOccurrenceRange", K::Struct),
8194 ("onlyActiveViolationsIncluded", K::Bool),
8195 ("suppressedAlertsIncluded", K::Bool),
8196 ("actionsDefinition", K::List),
8197 ("taskStatistics", K::Struct),
8198 ],
8199 list_scalar: false,
8200 req_payload: false,
8201 },
8202 OpMeta {
8203 op: "ListDimensions",
8204 method: "GET",
8205 segs: &[Seg::Fixed("dimensions")],
8206 verb: Verb::List,
8207 rtype: "dimensions",
8208 nlabels: 0,
8209 has_input: true,
8210 errors: &[
8211 "InternalFailureException",
8212 "InvalidRequestException",
8213 "ThrottlingException",
8214 ],
8215 rules: &[Rule {
8216 wire: "maxResults",
8217 src: Src::Query,
8218 req: false,
8219 kind: K::Int,
8220 min_len: None,
8221 max_len: None,
8222 min_val: Some(1),
8223 max_val: Some(250),
8224 enums: &[],
8225 }],
8226 omembers: &[("dimensionNames", K::List), ("nextToken", K::Str)],
8227 list_field: Some("dimensionNames"),
8228 list_elems: &[],
8229 list_scalar: true,
8230 req_payload: false,
8231 },
8232 OpMeta {
8233 op: "ListDomainConfigurations",
8234 method: "GET",
8235 segs: &[Seg::Fixed("domainConfigurations")],
8236 verb: Verb::List,
8237 rtype: "domainConfigurations",
8238 nlabels: 0,
8239 has_input: true,
8240 errors: &[
8241 "InternalFailureException",
8242 "InvalidRequestException",
8243 "ServiceUnavailableException",
8244 "ThrottlingException",
8245 "UnauthorizedException",
8246 ],
8247 rules: &[
8248 Rule {
8249 wire: "marker",
8250 src: Src::Query,
8251 req: false,
8252 kind: K::Str,
8253 min_len: Some(0),
8254 max_len: Some(1024),
8255 min_val: None,
8256 max_val: None,
8257 enums: &[],
8258 },
8259 Rule {
8260 wire: "pageSize",
8261 src: Src::Query,
8262 req: false,
8263 kind: K::Int,
8264 min_len: None,
8265 max_len: None,
8266 min_val: Some(1),
8267 max_val: Some(250),
8268 enums: &[],
8269 },
8270 Rule {
8271 wire: "serviceType",
8272 src: Src::Query,
8273 req: false,
8274 kind: K::Str,
8275 min_len: None,
8276 max_len: None,
8277 min_val: None,
8278 max_val: None,
8279 enums: &["DATA", "CREDENTIAL_PROVIDER", "JOBS"],
8280 },
8281 ],
8282 omembers: &[("domainConfigurations", K::List), ("nextMarker", K::Str)],
8283 list_field: Some("domainConfigurations"),
8284 list_elems: &[
8285 ("domainConfigurationName", K::Str),
8286 ("domainConfigurationArn", K::Str),
8287 ("serviceType", K::Str),
8288 ],
8289 list_scalar: false,
8290 req_payload: false,
8291 },
8292 OpMeta {
8293 op: "ListFleetMetrics",
8294 method: "GET",
8295 segs: &[Seg::Fixed("fleet-metrics")],
8296 verb: Verb::List,
8297 rtype: "fleet-metrics",
8298 nlabels: 0,
8299 has_input: true,
8300 errors: &[
8301 "InternalFailureException",
8302 "InvalidRequestException",
8303 "ServiceUnavailableException",
8304 "ThrottlingException",
8305 "UnauthorizedException",
8306 ],
8307 rules: &[Rule {
8308 wire: "maxResults",
8309 src: Src::Query,
8310 req: false,
8311 kind: K::Int,
8312 min_len: None,
8313 max_len: None,
8314 min_val: Some(1),
8315 max_val: Some(250),
8316 enums: &[],
8317 }],
8318 omembers: &[("fleetMetrics", K::List), ("nextToken", K::Str)],
8319 list_field: Some("fleetMetrics"),
8320 list_elems: &[("metricName", K::Str), ("metricArn", K::Str)],
8321 list_scalar: false,
8322 req_payload: false,
8323 },
8324 OpMeta {
8325 op: "ListIndices",
8326 method: "GET",
8327 segs: &[Seg::Fixed("indices")],
8328 verb: Verb::List,
8329 rtype: "indices",
8330 nlabels: 0,
8331 has_input: true,
8332 errors: &[
8333 "InternalFailureException",
8334 "InvalidRequestException",
8335 "ServiceUnavailableException",
8336 "ThrottlingException",
8337 "UnauthorizedException",
8338 ],
8339 rules: &[Rule {
8340 wire: "maxResults",
8341 src: Src::Query,
8342 req: false,
8343 kind: K::Int,
8344 min_len: None,
8345 max_len: None,
8346 min_val: Some(1),
8347 max_val: Some(500),
8348 enums: &[],
8349 }],
8350 omembers: &[("indexNames", K::List), ("nextToken", K::Str)],
8351 list_field: Some("indexNames"),
8352 list_elems: &[],
8353 list_scalar: true,
8354 req_payload: false,
8355 },
8356 OpMeta {
8357 op: "ListJobExecutionsForJob",
8358 method: "GET",
8359 segs: &[
8360 Seg::Fixed("jobs"),
8361 Seg::Label("jobId"),
8362 Seg::Fixed("things"),
8363 ],
8364 verb: Verb::List,
8365 rtype: "jobs",
8366 nlabels: 1,
8367 has_input: true,
8368 errors: &[
8369 "InvalidRequestException",
8370 "ResourceNotFoundException",
8371 "ServiceUnavailableException",
8372 "ThrottlingException",
8373 ],
8374 rules: &[
8375 Rule {
8376 wire: "jobId",
8377 src: Src::Label,
8378 req: true,
8379 kind: K::Str,
8380 min_len: Some(1),
8381 max_len: Some(64),
8382 min_val: None,
8383 max_val: None,
8384 enums: &[],
8385 },
8386 Rule {
8387 wire: "status",
8388 src: Src::Query,
8389 req: false,
8390 kind: K::Str,
8391 min_len: None,
8392 max_len: None,
8393 min_val: None,
8394 max_val: None,
8395 enums: &[
8396 "QUEUED",
8397 "IN_PROGRESS",
8398 "SUCCEEDED",
8399 "FAILED",
8400 "TIMED_OUT",
8401 "REJECTED",
8402 "REMOVED",
8403 "CANCELED",
8404 ],
8405 },
8406 Rule {
8407 wire: "maxResults",
8408 src: Src::Query,
8409 req: false,
8410 kind: K::Int,
8411 min_len: None,
8412 max_len: None,
8413 min_val: Some(1),
8414 max_val: Some(250),
8415 enums: &[],
8416 },
8417 ],
8418 omembers: &[("executionSummaries", K::List), ("nextToken", K::Str)],
8419 list_field: Some("executionSummaries"),
8420 list_elems: &[("thingArn", K::Str), ("jobExecutionSummary", K::Struct)],
8421 list_scalar: false,
8422 req_payload: false,
8423 },
8424 OpMeta {
8425 op: "ListJobExecutionsForThing",
8426 method: "GET",
8427 segs: &[
8428 Seg::Fixed("things"),
8429 Seg::Label("thingName"),
8430 Seg::Fixed("jobs"),
8431 ],
8432 verb: Verb::List,
8433 rtype: "things",
8434 nlabels: 1,
8435 has_input: true,
8436 errors: &[
8437 "InvalidRequestException",
8438 "ResourceNotFoundException",
8439 "ServiceUnavailableException",
8440 "ThrottlingException",
8441 ],
8442 rules: &[
8443 Rule {
8444 wire: "thingName",
8445 src: Src::Label,
8446 req: true,
8447 kind: K::Str,
8448 min_len: Some(1),
8449 max_len: Some(128),
8450 min_val: None,
8451 max_val: None,
8452 enums: &[],
8453 },
8454 Rule {
8455 wire: "status",
8456 src: Src::Query,
8457 req: false,
8458 kind: K::Str,
8459 min_len: None,
8460 max_len: None,
8461 min_val: None,
8462 max_val: None,
8463 enums: &[
8464 "QUEUED",
8465 "IN_PROGRESS",
8466 "SUCCEEDED",
8467 "FAILED",
8468 "TIMED_OUT",
8469 "REJECTED",
8470 "REMOVED",
8471 "CANCELED",
8472 ],
8473 },
8474 Rule {
8475 wire: "maxResults",
8476 src: Src::Query,
8477 req: false,
8478 kind: K::Int,
8479 min_len: None,
8480 max_len: None,
8481 min_val: Some(1),
8482 max_val: Some(250),
8483 enums: &[],
8484 },
8485 Rule {
8486 wire: "jobId",
8487 src: Src::Query,
8488 req: false,
8489 kind: K::Str,
8490 min_len: Some(1),
8491 max_len: Some(64),
8492 min_val: None,
8493 max_val: None,
8494 enums: &[],
8495 },
8496 ],
8497 omembers: &[("executionSummaries", K::List), ("nextToken", K::Str)],
8498 list_field: Some("executionSummaries"),
8499 list_elems: &[("jobId", K::Str), ("jobExecutionSummary", K::Struct)],
8500 list_scalar: false,
8501 req_payload: false,
8502 },
8503 OpMeta {
8504 op: "ListJobTemplates",
8505 method: "GET",
8506 segs: &[Seg::Fixed("job-templates")],
8507 verb: Verb::List,
8508 rtype: "job-templates",
8509 nlabels: 0,
8510 has_input: true,
8511 errors: &[
8512 "InternalFailureException",
8513 "InvalidRequestException",
8514 "ThrottlingException",
8515 ],
8516 rules: &[Rule {
8517 wire: "maxResults",
8518 src: Src::Query,
8519 req: false,
8520 kind: K::Int,
8521 min_len: None,
8522 max_len: None,
8523 min_val: Some(1),
8524 max_val: Some(250),
8525 enums: &[],
8526 }],
8527 omembers: &[("jobTemplates", K::List), ("nextToken", K::Str)],
8528 list_field: Some("jobTemplates"),
8529 list_elems: &[
8530 ("jobTemplateArn", K::Str),
8531 ("jobTemplateId", K::Str),
8532 ("description", K::Str),
8533 ("createdAt", K::Ts),
8534 ],
8535 list_scalar: false,
8536 req_payload: false,
8537 },
8538 OpMeta {
8539 op: "ListJobs",
8540 method: "GET",
8541 segs: &[Seg::Fixed("jobs")],
8542 verb: Verb::List,
8543 rtype: "jobs",
8544 nlabels: 0,
8545 has_input: true,
8546 errors: &[
8547 "InvalidRequestException",
8548 "ResourceNotFoundException",
8549 "ServiceUnavailableException",
8550 "ThrottlingException",
8551 ],
8552 rules: &[
8553 Rule {
8554 wire: "status",
8555 src: Src::Query,
8556 req: false,
8557 kind: K::Str,
8558 min_len: None,
8559 max_len: None,
8560 min_val: None,
8561 max_val: None,
8562 enums: &[
8563 "IN_PROGRESS",
8564 "CANCELED",
8565 "COMPLETED",
8566 "DELETION_IN_PROGRESS",
8567 "SCHEDULED",
8568 ],
8569 },
8570 Rule {
8571 wire: "targetSelection",
8572 src: Src::Query,
8573 req: false,
8574 kind: K::Str,
8575 min_len: None,
8576 max_len: None,
8577 min_val: None,
8578 max_val: None,
8579 enums: &["CONTINUOUS", "SNAPSHOT"],
8580 },
8581 Rule {
8582 wire: "maxResults",
8583 src: Src::Query,
8584 req: false,
8585 kind: K::Int,
8586 min_len: None,
8587 max_len: None,
8588 min_val: Some(1),
8589 max_val: Some(250),
8590 enums: &[],
8591 },
8592 Rule {
8593 wire: "thingGroupName",
8594 src: Src::Query,
8595 req: false,
8596 kind: K::Str,
8597 min_len: Some(1),
8598 max_len: Some(128),
8599 min_val: None,
8600 max_val: None,
8601 enums: &[],
8602 },
8603 Rule {
8604 wire: "thingGroupId",
8605 src: Src::Query,
8606 req: false,
8607 kind: K::Str,
8608 min_len: Some(1),
8609 max_len: Some(128),
8610 min_val: None,
8611 max_val: None,
8612 enums: &[],
8613 },
8614 ],
8615 omembers: &[("jobs", K::List), ("nextToken", K::Str)],
8616 list_field: Some("jobs"),
8617 list_elems: &[
8618 ("jobArn", K::Str),
8619 ("jobId", K::Str),
8620 ("thingGroupId", K::Str),
8621 ("targetSelection", K::Str),
8622 ("status", K::Str),
8623 ("createdAt", K::Ts),
8624 ("lastUpdatedAt", K::Ts),
8625 ("completedAt", K::Ts),
8626 ("isConcurrent", K::Bool),
8627 ],
8628 list_scalar: false,
8629 req_payload: false,
8630 },
8631 OpMeta {
8632 op: "ListManagedJobTemplates",
8633 method: "GET",
8634 segs: &[Seg::Fixed("managed-job-templates")],
8635 verb: Verb::List,
8636 rtype: "managed-job-templates",
8637 nlabels: 0,
8638 has_input: true,
8639 errors: &[
8640 "InternalServerException",
8641 "InvalidRequestException",
8642 "ResourceNotFoundException",
8643 "ThrottlingException",
8644 ],
8645 rules: &[
8646 Rule {
8647 wire: "templateName",
8648 src: Src::Query,
8649 req: false,
8650 kind: K::Str,
8651 min_len: Some(1),
8652 max_len: Some(64),
8653 min_val: None,
8654 max_val: None,
8655 enums: &[],
8656 },
8657 Rule {
8658 wire: "maxResults",
8659 src: Src::Query,
8660 req: false,
8661 kind: K::Int,
8662 min_len: None,
8663 max_len: None,
8664 min_val: Some(1),
8665 max_val: Some(250),
8666 enums: &[],
8667 },
8668 ],
8669 omembers: &[("managedJobTemplates", K::List), ("nextToken", K::Str)],
8670 list_field: Some("managedJobTemplates"),
8671 list_elems: &[
8672 ("templateArn", K::Str),
8673 ("templateName", K::Str),
8674 ("description", K::Str),
8675 ("environments", K::List),
8676 ("templateVersion", K::Str),
8677 ],
8678 list_scalar: false,
8679 req_payload: false,
8680 },
8681 OpMeta {
8682 op: "ListMetricValues",
8683 method: "GET",
8684 segs: &[Seg::Fixed("metric-values")],
8685 verb: Verb::List,
8686 rtype: "metric-values",
8687 nlabels: 0,
8688 has_input: true,
8689 errors: &[
8690 "InternalFailureException",
8691 "InvalidRequestException",
8692 "ResourceNotFoundException",
8693 "ThrottlingException",
8694 ],
8695 rules: &[
8696 Rule {
8697 wire: "thingName",
8698 src: Src::Query,
8699 req: true,
8700 kind: K::Str,
8701 min_len: Some(1),
8702 max_len: Some(128),
8703 min_val: None,
8704 max_val: None,
8705 enums: &[],
8706 },
8707 Rule {
8708 wire: "metricName",
8709 src: Src::Query,
8710 req: true,
8711 kind: K::Str,
8712 min_len: None,
8713 max_len: None,
8714 min_val: None,
8715 max_val: None,
8716 enums: &[],
8717 },
8718 Rule {
8719 wire: "dimensionName",
8720 src: Src::Query,
8721 req: false,
8722 kind: K::Str,
8723 min_len: Some(1),
8724 max_len: Some(128),
8725 min_val: None,
8726 max_val: None,
8727 enums: &[],
8728 },
8729 Rule {
8730 wire: "dimensionValueOperator",
8731 src: Src::Query,
8732 req: false,
8733 kind: K::Str,
8734 min_len: None,
8735 max_len: None,
8736 min_val: None,
8737 max_val: None,
8738 enums: &["IN", "NOT_IN"],
8739 },
8740 Rule {
8741 wire: "startTime",
8742 src: Src::Query,
8743 req: true,
8744 kind: K::Ts,
8745 min_len: None,
8746 max_len: None,
8747 min_val: None,
8748 max_val: None,
8749 enums: &[],
8750 },
8751 Rule {
8752 wire: "endTime",
8753 src: Src::Query,
8754 req: true,
8755 kind: K::Ts,
8756 min_len: None,
8757 max_len: None,
8758 min_val: None,
8759 max_val: None,
8760 enums: &[],
8761 },
8762 Rule {
8763 wire: "maxResults",
8764 src: Src::Query,
8765 req: false,
8766 kind: K::Int,
8767 min_len: None,
8768 max_len: None,
8769 min_val: Some(1),
8770 max_val: Some(250),
8771 enums: &[],
8772 },
8773 ],
8774 omembers: &[("metricDatumList", K::List), ("nextToken", K::Str)],
8775 list_field: Some("metricDatumList"),
8776 list_elems: &[("timestamp", K::Ts), ("value", K::Struct)],
8777 list_scalar: false,
8778 req_payload: false,
8779 },
8780 OpMeta {
8781 op: "ListMitigationActions",
8782 method: "GET",
8783 segs: &[Seg::Fixed("mitigationactions"), Seg::Fixed("actions")],
8784 verb: Verb::List,
8785 rtype: "mitigationactions",
8786 nlabels: 0,
8787 has_input: true,
8788 errors: &[
8789 "InternalFailureException",
8790 "InvalidRequestException",
8791 "ThrottlingException",
8792 ],
8793 rules: &[
8794 Rule {
8795 wire: "actionType",
8796 src: Src::Query,
8797 req: false,
8798 kind: K::Str,
8799 min_len: None,
8800 max_len: None,
8801 min_val: None,
8802 max_val: None,
8803 enums: &[
8804 "UPDATE_DEVICE_CERTIFICATE",
8805 "UPDATE_CA_CERTIFICATE",
8806 "ADD_THINGS_TO_THING_GROUP",
8807 "REPLACE_DEFAULT_POLICY_VERSION",
8808 "ENABLE_IOT_LOGGING",
8809 "PUBLISH_FINDING_TO_SNS",
8810 ],
8811 },
8812 Rule {
8813 wire: "maxResults",
8814 src: Src::Query,
8815 req: false,
8816 kind: K::Int,
8817 min_len: None,
8818 max_len: None,
8819 min_val: Some(1),
8820 max_val: Some(250),
8821 enums: &[],
8822 },
8823 ],
8824 omembers: &[("actionIdentifiers", K::List), ("nextToken", K::Str)],
8825 list_field: Some("actionIdentifiers"),
8826 list_elems: &[
8827 ("actionName", K::Str),
8828 ("actionArn", K::Str),
8829 ("creationDate", K::Ts),
8830 ],
8831 list_scalar: false,
8832 req_payload: false,
8833 },
8834 OpMeta {
8835 op: "ListOTAUpdates",
8836 method: "GET",
8837 segs: &[Seg::Fixed("otaUpdates")],
8838 verb: Verb::List,
8839 rtype: "otaUpdates",
8840 nlabels: 0,
8841 has_input: true,
8842 errors: &[
8843 "InternalFailureException",
8844 "InvalidRequestException",
8845 "ServiceUnavailableException",
8846 "ThrottlingException",
8847 "UnauthorizedException",
8848 ],
8849 rules: &[
8850 Rule {
8851 wire: "maxResults",
8852 src: Src::Query,
8853 req: false,
8854 kind: K::Int,
8855 min_len: None,
8856 max_len: None,
8857 min_val: Some(1),
8858 max_val: Some(250),
8859 enums: &[],
8860 },
8861 Rule {
8862 wire: "otaUpdateStatus",
8863 src: Src::Query,
8864 req: false,
8865 kind: K::Str,
8866 min_len: None,
8867 max_len: None,
8868 min_val: None,
8869 max_val: None,
8870 enums: &[
8871 "CREATE_PENDING",
8872 "CREATE_IN_PROGRESS",
8873 "CREATE_COMPLETE",
8874 "CREATE_FAILED",
8875 "DELETE_IN_PROGRESS",
8876 "DELETE_FAILED",
8877 ],
8878 },
8879 ],
8880 omembers: &[("otaUpdates", K::List), ("nextToken", K::Str)],
8881 list_field: Some("otaUpdates"),
8882 list_elems: &[
8883 ("otaUpdateId", K::Str),
8884 ("otaUpdateArn", K::Str),
8885 ("creationDate", K::Ts),
8886 ],
8887 list_scalar: false,
8888 req_payload: false,
8889 },
8890 OpMeta {
8891 op: "ListOutgoingCertificates",
8892 method: "GET",
8893 segs: &[Seg::Fixed("certificates-out-going")],
8894 verb: Verb::List,
8895 rtype: "certificates-out-going",
8896 nlabels: 0,
8897 has_input: true,
8898 errors: &[
8899 "InternalFailureException",
8900 "InvalidRequestException",
8901 "ServiceUnavailableException",
8902 "ThrottlingException",
8903 "UnauthorizedException",
8904 ],
8905 rules: &[
8906 Rule {
8907 wire: "pageSize",
8908 src: Src::Query,
8909 req: false,
8910 kind: K::Int,
8911 min_len: None,
8912 max_len: None,
8913 min_val: Some(1),
8914 max_val: Some(250),
8915 enums: &[],
8916 },
8917 Rule {
8918 wire: "marker",
8919 src: Src::Query,
8920 req: false,
8921 kind: K::Str,
8922 min_len: Some(0),
8923 max_len: Some(1024),
8924 min_val: None,
8925 max_val: None,
8926 enums: &[],
8927 },
8928 ],
8929 omembers: &[("outgoingCertificates", K::List), ("nextMarker", K::Str)],
8930 list_field: Some("outgoingCertificates"),
8931 list_elems: &[
8932 ("certificateArn", K::Str),
8933 ("certificateId", K::Str),
8934 ("transferredTo", K::Str),
8935 ("transferDate", K::Ts),
8936 ("transferMessage", K::Str),
8937 ("creationDate", K::Ts),
8938 ],
8939 list_scalar: false,
8940 req_payload: false,
8941 },
8942 OpMeta {
8943 op: "ListPackageVersions",
8944 method: "GET",
8945 segs: &[
8946 Seg::Fixed("packages"),
8947 Seg::Label("packageName"),
8948 Seg::Fixed("versions"),
8949 ],
8950 verb: Verb::List,
8951 rtype: "packages",
8952 nlabels: 1,
8953 has_input: true,
8954 errors: &[
8955 "InternalServerException",
8956 "ThrottlingException",
8957 "ValidationException",
8958 ],
8959 rules: &[
8960 Rule {
8961 wire: "packageName",
8962 src: Src::Label,
8963 req: true,
8964 kind: K::Str,
8965 min_len: Some(1),
8966 max_len: Some(128),
8967 min_val: None,
8968 max_val: None,
8969 enums: &[],
8970 },
8971 Rule {
8972 wire: "status",
8973 src: Src::Query,
8974 req: false,
8975 kind: K::Str,
8976 min_len: None,
8977 max_len: None,
8978 min_val: None,
8979 max_val: None,
8980 enums: &["DRAFT", "PUBLISHED", "DEPRECATED"],
8981 },
8982 Rule {
8983 wire: "maxResults",
8984 src: Src::Query,
8985 req: false,
8986 kind: K::Int,
8987 min_len: None,
8988 max_len: None,
8989 min_val: Some(1),
8990 max_val: Some(100),
8991 enums: &[],
8992 },
8993 ],
8994 omembers: &[("packageVersionSummaries", K::List), ("nextToken", K::Str)],
8995 list_field: Some("packageVersionSummaries"),
8996 list_elems: &[
8997 ("packageName", K::Str),
8998 ("versionName", K::Str),
8999 ("status", K::Str),
9000 ("creationDate", K::Ts),
9001 ("lastModifiedDate", K::Ts),
9002 ],
9003 list_scalar: false,
9004 req_payload: false,
9005 },
9006 OpMeta {
9007 op: "ListPackages",
9008 method: "GET",
9009 segs: &[Seg::Fixed("packages")],
9010 verb: Verb::List,
9011 rtype: "packages",
9012 nlabels: 0,
9013 has_input: true,
9014 errors: &[
9015 "InternalServerException",
9016 "ThrottlingException",
9017 "ValidationException",
9018 ],
9019 rules: &[Rule {
9020 wire: "maxResults",
9021 src: Src::Query,
9022 req: false,
9023 kind: K::Int,
9024 min_len: None,
9025 max_len: None,
9026 min_val: Some(1),
9027 max_val: Some(100),
9028 enums: &[],
9029 }],
9030 omembers: &[("packageSummaries", K::List), ("nextToken", K::Str)],
9031 list_field: Some("packageSummaries"),
9032 list_elems: &[
9033 ("packageName", K::Str),
9034 ("defaultVersionName", K::Str),
9035 ("creationDate", K::Ts),
9036 ("lastModifiedDate", K::Ts),
9037 ],
9038 list_scalar: false,
9039 req_payload: false,
9040 },
9041 OpMeta {
9042 op: "ListPolicies",
9043 method: "GET",
9044 segs: &[Seg::Fixed("policies")],
9045 verb: Verb::List,
9046 rtype: "policies",
9047 nlabels: 0,
9048 has_input: true,
9049 errors: &[
9050 "InternalFailureException",
9051 "InvalidRequestException",
9052 "ServiceUnavailableException",
9053 "ThrottlingException",
9054 "UnauthorizedException",
9055 ],
9056 rules: &[
9057 Rule {
9058 wire: "marker",
9059 src: Src::Query,
9060 req: false,
9061 kind: K::Str,
9062 min_len: Some(0),
9063 max_len: Some(1024),
9064 min_val: None,
9065 max_val: None,
9066 enums: &[],
9067 },
9068 Rule {
9069 wire: "pageSize",
9070 src: Src::Query,
9071 req: false,
9072 kind: K::Int,
9073 min_len: None,
9074 max_len: None,
9075 min_val: Some(1),
9076 max_val: Some(250),
9077 enums: &[],
9078 },
9079 ],
9080 omembers: &[("policies", K::List), ("nextMarker", K::Str)],
9081 list_field: Some("policies"),
9082 list_elems: &[("policyName", K::Str), ("policyArn", K::Str)],
9083 list_scalar: false,
9084 req_payload: false,
9085 },
9086 OpMeta {
9087 op: "ListPolicyPrincipals",
9088 method: "GET",
9089 segs: &[Seg::Fixed("policy-principals")],
9090 verb: Verb::List,
9091 rtype: "policy-principals",
9092 nlabels: 0,
9093 has_input: true,
9094 errors: &[
9095 "InternalFailureException",
9096 "InvalidRequestException",
9097 "ResourceNotFoundException",
9098 "ServiceUnavailableException",
9099 "ThrottlingException",
9100 "UnauthorizedException",
9101 ],
9102 rules: &[
9103 Rule {
9104 wire: "x-amzn-iot-policy",
9105 src: Src::Header,
9106 req: true,
9107 kind: K::Str,
9108 min_len: Some(1),
9109 max_len: Some(128),
9110 min_val: None,
9111 max_val: None,
9112 enums: &[],
9113 },
9114 Rule {
9115 wire: "marker",
9116 src: Src::Query,
9117 req: false,
9118 kind: K::Str,
9119 min_len: Some(0),
9120 max_len: Some(1024),
9121 min_val: None,
9122 max_val: None,
9123 enums: &[],
9124 },
9125 Rule {
9126 wire: "pageSize",
9127 src: Src::Query,
9128 req: false,
9129 kind: K::Int,
9130 min_len: None,
9131 max_len: None,
9132 min_val: Some(1),
9133 max_val: Some(250),
9134 enums: &[],
9135 },
9136 ],
9137 omembers: &[("principals", K::List), ("nextMarker", K::Str)],
9138 list_field: Some("principals"),
9139 list_elems: &[],
9140 list_scalar: true,
9141 req_payload: false,
9142 },
9143 OpMeta {
9144 op: "ListPolicyVersions",
9145 method: "GET",
9146 segs: &[
9147 Seg::Fixed("policies"),
9148 Seg::Label("policyName"),
9149 Seg::Fixed("version"),
9150 ],
9151 verb: Verb::List,
9152 rtype: "policies",
9153 nlabels: 1,
9154 has_input: true,
9155 errors: &[
9156 "InternalFailureException",
9157 "InvalidRequestException",
9158 "ResourceNotFoundException",
9159 "ServiceUnavailableException",
9160 "ThrottlingException",
9161 "UnauthorizedException",
9162 ],
9163 rules: &[Rule {
9164 wire: "policyName",
9165 src: Src::Label,
9166 req: true,
9167 kind: K::Str,
9168 min_len: Some(1),
9169 max_len: Some(128),
9170 min_val: None,
9171 max_val: None,
9172 enums: &[],
9173 }],
9174 omembers: &[("policyVersions", K::List)],
9175 list_field: Some("policyVersions"),
9176 list_elems: &[
9177 ("versionId", K::Str),
9178 ("isDefaultVersion", K::Bool),
9179 ("createDate", K::Ts),
9180 ],
9181 list_scalar: false,
9182 req_payload: false,
9183 },
9184 OpMeta {
9185 op: "ListPrincipalPolicies",
9186 method: "GET",
9187 segs: &[Seg::Fixed("principal-policies")],
9188 verb: Verb::List,
9189 rtype: "principal-policies",
9190 nlabels: 0,
9191 has_input: true,
9192 errors: &[
9193 "InternalFailureException",
9194 "InvalidRequestException",
9195 "ResourceNotFoundException",
9196 "ServiceUnavailableException",
9197 "ThrottlingException",
9198 "UnauthorizedException",
9199 ],
9200 rules: &[
9201 Rule {
9202 wire: "x-amzn-iot-principal",
9203 src: Src::Header,
9204 req: true,
9205 kind: K::Str,
9206 min_len: None,
9207 max_len: None,
9208 min_val: None,
9209 max_val: None,
9210 enums: &[],
9211 },
9212 Rule {
9213 wire: "marker",
9214 src: Src::Query,
9215 req: false,
9216 kind: K::Str,
9217 min_len: Some(0),
9218 max_len: Some(1024),
9219 min_val: None,
9220 max_val: None,
9221 enums: &[],
9222 },
9223 Rule {
9224 wire: "pageSize",
9225 src: Src::Query,
9226 req: false,
9227 kind: K::Int,
9228 min_len: None,
9229 max_len: None,
9230 min_val: Some(1),
9231 max_val: Some(250),
9232 enums: &[],
9233 },
9234 ],
9235 omembers: &[("policies", K::List), ("nextMarker", K::Str)],
9236 list_field: Some("policies"),
9237 list_elems: &[("policyName", K::Str), ("policyArn", K::Str)],
9238 list_scalar: false,
9239 req_payload: false,
9240 },
9241 OpMeta {
9242 op: "ListPrincipalThings",
9243 method: "GET",
9244 segs: &[Seg::Fixed("principals"), Seg::Fixed("things")],
9245 verb: Verb::List,
9246 rtype: "principals",
9247 nlabels: 0,
9248 has_input: true,
9249 errors: &[
9250 "InternalFailureException",
9251 "InvalidRequestException",
9252 "ResourceNotFoundException",
9253 "ServiceUnavailableException",
9254 "ThrottlingException",
9255 "UnauthorizedException",
9256 ],
9257 rules: &[
9258 Rule {
9259 wire: "maxResults",
9260 src: Src::Query,
9261 req: false,
9262 kind: K::Int,
9263 min_len: None,
9264 max_len: None,
9265 min_val: Some(1),
9266 max_val: Some(250),
9267 enums: &[],
9268 },
9269 Rule {
9270 wire: "x-amzn-principal",
9271 src: Src::Header,
9272 req: true,
9273 kind: K::Str,
9274 min_len: None,
9275 max_len: None,
9276 min_val: None,
9277 max_val: None,
9278 enums: &[],
9279 },
9280 ],
9281 omembers: &[("things", K::List), ("nextToken", K::Str)],
9282 list_field: Some("things"),
9283 list_elems: &[],
9284 list_scalar: true,
9285 req_payload: false,
9286 },
9287 OpMeta {
9288 op: "ListPrincipalThingsV2",
9289 method: "GET",
9290 segs: &[Seg::Fixed("principals"), Seg::Fixed("things-v2")],
9291 verb: Verb::List,
9292 rtype: "principals",
9293 nlabels: 0,
9294 has_input: true,
9295 errors: &[
9296 "InternalFailureException",
9297 "InvalidRequestException",
9298 "ResourceNotFoundException",
9299 "ServiceUnavailableException",
9300 "ThrottlingException",
9301 "UnauthorizedException",
9302 ],
9303 rules: &[
9304 Rule {
9305 wire: "maxResults",
9306 src: Src::Query,
9307 req: false,
9308 kind: K::Int,
9309 min_len: None,
9310 max_len: None,
9311 min_val: Some(1),
9312 max_val: Some(250),
9313 enums: &[],
9314 },
9315 Rule {
9316 wire: "x-amzn-principal",
9317 src: Src::Header,
9318 req: true,
9319 kind: K::Str,
9320 min_len: None,
9321 max_len: None,
9322 min_val: None,
9323 max_val: None,
9324 enums: &[],
9325 },
9326 Rule {
9327 wire: "thingPrincipalType",
9328 src: Src::Query,
9329 req: false,
9330 kind: K::Str,
9331 min_len: None,
9332 max_len: None,
9333 min_val: None,
9334 max_val: None,
9335 enums: &["EXCLUSIVE_THING", "NON_EXCLUSIVE_THING"],
9336 },
9337 ],
9338 omembers: &[("principalThingObjects", K::List), ("nextToken", K::Str)],
9339 list_field: Some("principalThingObjects"),
9340 list_elems: &[("thingName", K::Str), ("thingPrincipalType", K::Str)],
9341 list_scalar: false,
9342 req_payload: false,
9343 },
9344 OpMeta {
9345 op: "ListProvisioningTemplateVersions",
9346 method: "GET",
9347 segs: &[
9348 Seg::Fixed("provisioning-templates"),
9349 Seg::Label("templateName"),
9350 Seg::Fixed("versions"),
9351 ],
9352 verb: Verb::List,
9353 rtype: "provisioning-templates",
9354 nlabels: 1,
9355 has_input: true,
9356 errors: &[
9357 "InternalFailureException",
9358 "InvalidRequestException",
9359 "ResourceNotFoundException",
9360 "ThrottlingException",
9361 "UnauthorizedException",
9362 ],
9363 rules: &[
9364 Rule {
9365 wire: "templateName",
9366 src: Src::Label,
9367 req: true,
9368 kind: K::Str,
9369 min_len: Some(1),
9370 max_len: Some(36),
9371 min_val: None,
9372 max_val: None,
9373 enums: &[],
9374 },
9375 Rule {
9376 wire: "maxResults",
9377 src: Src::Query,
9378 req: false,
9379 kind: K::Int,
9380 min_len: None,
9381 max_len: None,
9382 min_val: Some(1),
9383 max_val: Some(250),
9384 enums: &[],
9385 },
9386 ],
9387 omembers: &[("versions", K::List), ("nextToken", K::Str)],
9388 list_field: Some("versions"),
9389 list_elems: &[
9390 ("versionId", K::Int),
9391 ("creationDate", K::Ts),
9392 ("isDefaultVersion", K::Bool),
9393 ],
9394 list_scalar: false,
9395 req_payload: false,
9396 },
9397 OpMeta {
9398 op: "ListProvisioningTemplates",
9399 method: "GET",
9400 segs: &[Seg::Fixed("provisioning-templates")],
9401 verb: Verb::List,
9402 rtype: "provisioning-templates",
9403 nlabels: 0,
9404 has_input: true,
9405 errors: &[
9406 "InternalFailureException",
9407 "InvalidRequestException",
9408 "ThrottlingException",
9409 "UnauthorizedException",
9410 ],
9411 rules: &[Rule {
9412 wire: "maxResults",
9413 src: Src::Query,
9414 req: false,
9415 kind: K::Int,
9416 min_len: None,
9417 max_len: None,
9418 min_val: Some(1),
9419 max_val: Some(250),
9420 enums: &[],
9421 }],
9422 omembers: &[("templates", K::List), ("nextToken", K::Str)],
9423 list_field: Some("templates"),
9424 list_elems: &[
9425 ("templateArn", K::Str),
9426 ("templateName", K::Str),
9427 ("description", K::Str),
9428 ("creationDate", K::Ts),
9429 ("lastModifiedDate", K::Ts),
9430 ("enabled", K::Bool),
9431 ("type", K::Str),
9432 ],
9433 list_scalar: false,
9434 req_payload: false,
9435 },
9436 OpMeta {
9437 op: "ListRelatedResourcesForAuditFinding",
9438 method: "GET",
9439 segs: &[Seg::Fixed("audit"), Seg::Fixed("relatedResources")],
9440 verb: Verb::List,
9441 rtype: "audit",
9442 nlabels: 0,
9443 has_input: true,
9444 errors: &[
9445 "InternalFailureException",
9446 "InvalidRequestException",
9447 "ResourceNotFoundException",
9448 "ThrottlingException",
9449 ],
9450 rules: &[
9451 Rule {
9452 wire: "findingId",
9453 src: Src::Query,
9454 req: true,
9455 kind: K::Str,
9456 min_len: Some(1),
9457 max_len: Some(128),
9458 min_val: None,
9459 max_val: None,
9460 enums: &[],
9461 },
9462 Rule {
9463 wire: "maxResults",
9464 src: Src::Query,
9465 req: false,
9466 kind: K::Int,
9467 min_len: None,
9468 max_len: None,
9469 min_val: Some(1),
9470 max_val: Some(250),
9471 enums: &[],
9472 },
9473 ],
9474 omembers: &[("relatedResources", K::List), ("nextToken", K::Str)],
9475 list_field: Some("relatedResources"),
9476 list_elems: &[
9477 ("resourceType", K::Str),
9478 ("resourceIdentifier", K::Struct),
9479 ("additionalInfo", K::Map),
9480 ],
9481 list_scalar: false,
9482 req_payload: false,
9483 },
9484 OpMeta {
9485 op: "ListRoleAliases",
9486 method: "GET",
9487 segs: &[Seg::Fixed("role-aliases")],
9488 verb: Verb::List,
9489 rtype: "role-aliases",
9490 nlabels: 0,
9491 has_input: true,
9492 errors: &[
9493 "InternalFailureException",
9494 "InvalidRequestException",
9495 "ServiceUnavailableException",
9496 "ThrottlingException",
9497 "UnauthorizedException",
9498 ],
9499 rules: &[
9500 Rule {
9501 wire: "pageSize",
9502 src: Src::Query,
9503 req: false,
9504 kind: K::Int,
9505 min_len: None,
9506 max_len: None,
9507 min_val: Some(1),
9508 max_val: Some(250),
9509 enums: &[],
9510 },
9511 Rule {
9512 wire: "marker",
9513 src: Src::Query,
9514 req: false,
9515 kind: K::Str,
9516 min_len: Some(0),
9517 max_len: Some(1024),
9518 min_val: None,
9519 max_val: None,
9520 enums: &[],
9521 },
9522 ],
9523 omembers: &[("roleAliases", K::List), ("nextMarker", K::Str)],
9524 list_field: Some("roleAliases"),
9525 list_elems: &[],
9526 list_scalar: true,
9527 req_payload: false,
9528 },
9529 OpMeta {
9530 op: "ListSbomValidationResults",
9531 method: "GET",
9532 segs: &[
9533 Seg::Fixed("packages"),
9534 Seg::Label("packageName"),
9535 Seg::Fixed("versions"),
9536 Seg::Label("versionName"),
9537 Seg::Fixed("sbom-validation-results"),
9538 ],
9539 verb: Verb::List,
9540 rtype: "packages",
9541 nlabels: 2,
9542 has_input: true,
9543 errors: &[
9544 "InternalServerException",
9545 "ResourceNotFoundException",
9546 "ThrottlingException",
9547 "ValidationException",
9548 ],
9549 rules: &[
9550 Rule {
9551 wire: "packageName",
9552 src: Src::Label,
9553 req: true,
9554 kind: K::Str,
9555 min_len: Some(1),
9556 max_len: Some(128),
9557 min_val: None,
9558 max_val: None,
9559 enums: &[],
9560 },
9561 Rule {
9562 wire: "versionName",
9563 src: Src::Label,
9564 req: true,
9565 kind: K::Str,
9566 min_len: Some(1),
9567 max_len: Some(64),
9568 min_val: None,
9569 max_val: None,
9570 enums: &[],
9571 },
9572 Rule {
9573 wire: "validationResult",
9574 src: Src::Query,
9575 req: false,
9576 kind: K::Str,
9577 min_len: None,
9578 max_len: None,
9579 min_val: None,
9580 max_val: None,
9581 enums: &["FAILED", "SUCCEEDED"],
9582 },
9583 Rule {
9584 wire: "maxResults",
9585 src: Src::Query,
9586 req: false,
9587 kind: K::Int,
9588 min_len: None,
9589 max_len: None,
9590 min_val: Some(1),
9591 max_val: Some(100),
9592 enums: &[],
9593 },
9594 ],
9595 omembers: &[
9596 ("validationResultSummaries", K::List),
9597 ("nextToken", K::Str),
9598 ],
9599 list_field: Some("validationResultSummaries"),
9600 list_elems: &[
9601 ("fileName", K::Str),
9602 ("validationResult", K::Str),
9603 ("errorCode", K::Str),
9604 ("errorMessage", K::Str),
9605 ],
9606 list_scalar: false,
9607 req_payload: false,
9608 },
9609 OpMeta {
9610 op: "ListScheduledAudits",
9611 method: "GET",
9612 segs: &[Seg::Fixed("audit"), Seg::Fixed("scheduledaudits")],
9613 verb: Verb::List,
9614 rtype: "audit",
9615 nlabels: 0,
9616 has_input: true,
9617 errors: &[
9618 "InternalFailureException",
9619 "InvalidRequestException",
9620 "ThrottlingException",
9621 ],
9622 rules: &[Rule {
9623 wire: "maxResults",
9624 src: Src::Query,
9625 req: false,
9626 kind: K::Int,
9627 min_len: None,
9628 max_len: None,
9629 min_val: Some(1),
9630 max_val: Some(250),
9631 enums: &[],
9632 }],
9633 omembers: &[("scheduledAudits", K::List), ("nextToken", K::Str)],
9634 list_field: Some("scheduledAudits"),
9635 list_elems: &[
9636 ("scheduledAuditName", K::Str),
9637 ("scheduledAuditArn", K::Str),
9638 ("frequency", K::Str),
9639 ("dayOfMonth", K::Str),
9640 ("dayOfWeek", K::Str),
9641 ],
9642 list_scalar: false,
9643 req_payload: false,
9644 },
9645 OpMeta {
9646 op: "ListSecurityProfiles",
9647 method: "GET",
9648 segs: &[Seg::Fixed("security-profiles")],
9649 verb: Verb::List,
9650 rtype: "security-profiles",
9651 nlabels: 0,
9652 has_input: true,
9653 errors: &[
9654 "InternalFailureException",
9655 "InvalidRequestException",
9656 "ResourceNotFoundException",
9657 "ThrottlingException",
9658 ],
9659 rules: &[
9660 Rule {
9661 wire: "maxResults",
9662 src: Src::Query,
9663 req: false,
9664 kind: K::Int,
9665 min_len: None,
9666 max_len: None,
9667 min_val: Some(1),
9668 max_val: Some(250),
9669 enums: &[],
9670 },
9671 Rule {
9672 wire: "dimensionName",
9673 src: Src::Query,
9674 req: false,
9675 kind: K::Str,
9676 min_len: Some(1),
9677 max_len: Some(128),
9678 min_val: None,
9679 max_val: None,
9680 enums: &[],
9681 },
9682 Rule {
9683 wire: "metricName",
9684 src: Src::Query,
9685 req: false,
9686 kind: K::Str,
9687 min_len: Some(1),
9688 max_len: Some(128),
9689 min_val: None,
9690 max_val: None,
9691 enums: &[],
9692 },
9693 ],
9694 omembers: &[
9695 ("securityProfileIdentifiers", K::List),
9696 ("nextToken", K::Str),
9697 ],
9698 list_field: Some("securityProfileIdentifiers"),
9699 list_elems: &[("name", K::Str), ("arn", K::Str)],
9700 list_scalar: false,
9701 req_payload: false,
9702 },
9703 OpMeta {
9704 op: "ListSecurityProfilesForTarget",
9705 method: "GET",
9706 segs: &[Seg::Fixed("security-profiles-for-target")],
9707 verb: Verb::List,
9708 rtype: "security-profiles-for-target",
9709 nlabels: 0,
9710 has_input: true,
9711 errors: &[
9712 "InternalFailureException",
9713 "InvalidRequestException",
9714 "ResourceNotFoundException",
9715 "ThrottlingException",
9716 ],
9717 rules: &[
9718 Rule {
9719 wire: "maxResults",
9720 src: Src::Query,
9721 req: false,
9722 kind: K::Int,
9723 min_len: None,
9724 max_len: None,
9725 min_val: Some(1),
9726 max_val: Some(250),
9727 enums: &[],
9728 },
9729 Rule {
9730 wire: "securityProfileTargetArn",
9731 src: Src::Query,
9732 req: true,
9733 kind: K::Str,
9734 min_len: None,
9735 max_len: None,
9736 min_val: None,
9737 max_val: None,
9738 enums: &[],
9739 },
9740 ],
9741 omembers: &[
9742 ("securityProfileTargetMappings", K::List),
9743 ("nextToken", K::Str),
9744 ],
9745 list_field: Some("securityProfileTargetMappings"),
9746 list_elems: &[
9747 ("securityProfileIdentifier", K::Struct),
9748 ("target", K::Struct),
9749 ],
9750 list_scalar: false,
9751 req_payload: false,
9752 },
9753 OpMeta {
9754 op: "ListStreams",
9755 method: "GET",
9756 segs: &[Seg::Fixed("streams")],
9757 verb: Verb::List,
9758 rtype: "streams",
9759 nlabels: 0,
9760 has_input: true,
9761 errors: &[
9762 "InternalFailureException",
9763 "InvalidRequestException",
9764 "ServiceUnavailableException",
9765 "ThrottlingException",
9766 "UnauthorizedException",
9767 ],
9768 rules: &[Rule {
9769 wire: "maxResults",
9770 src: Src::Query,
9771 req: false,
9772 kind: K::Int,
9773 min_len: None,
9774 max_len: None,
9775 min_val: Some(1),
9776 max_val: Some(250),
9777 enums: &[],
9778 }],
9779 omembers: &[("streams", K::List), ("nextToken", K::Str)],
9780 list_field: Some("streams"),
9781 list_elems: &[
9782 ("streamId", K::Str),
9783 ("streamArn", K::Str),
9784 ("streamVersion", K::Int),
9785 ("description", K::Str),
9786 ],
9787 list_scalar: false,
9788 req_payload: false,
9789 },
9790 OpMeta {
9791 op: "ListTagsForResource",
9792 method: "GET",
9793 segs: &[Seg::Fixed("tags")],
9794 verb: Verb::List,
9795 rtype: "tags",
9796 nlabels: 0,
9797 has_input: true,
9798 errors: &[
9799 "InternalFailureException",
9800 "InvalidRequestException",
9801 "ResourceNotFoundException",
9802 "ThrottlingException",
9803 ],
9804 rules: &[Rule {
9805 wire: "resourceArn",
9806 src: Src::Query,
9807 req: true,
9808 kind: K::Str,
9809 min_len: None,
9810 max_len: None,
9811 min_val: None,
9812 max_val: None,
9813 enums: &[],
9814 }],
9815 omembers: &[("tags", K::List), ("nextToken", K::Str)],
9816 list_field: Some("tags"),
9817 list_elems: &[("Key", K::Str), ("Value", K::Str)],
9818 list_scalar: false,
9819 req_payload: false,
9820 },
9821 OpMeta {
9822 op: "ListTargetsForPolicy",
9823 method: "POST",
9824 segs: &[Seg::Fixed("policy-targets"), Seg::Label("policyName")],
9825 verb: Verb::List,
9826 rtype: "policy-targets",
9827 nlabels: 1,
9828 has_input: true,
9829 errors: &[
9830 "InternalFailureException",
9831 "InvalidRequestException",
9832 "LimitExceededException",
9833 "ResourceNotFoundException",
9834 "ServiceUnavailableException",
9835 "ThrottlingException",
9836 "UnauthorizedException",
9837 ],
9838 rules: &[
9839 Rule {
9840 wire: "policyName",
9841 src: Src::Label,
9842 req: true,
9843 kind: K::Str,
9844 min_len: Some(1),
9845 max_len: Some(128),
9846 min_val: None,
9847 max_val: None,
9848 enums: &[],
9849 },
9850 Rule {
9851 wire: "marker",
9852 src: Src::Query,
9853 req: false,
9854 kind: K::Str,
9855 min_len: Some(0),
9856 max_len: Some(1024),
9857 min_val: None,
9858 max_val: None,
9859 enums: &[],
9860 },
9861 Rule {
9862 wire: "pageSize",
9863 src: Src::Query,
9864 req: false,
9865 kind: K::Int,
9866 min_len: None,
9867 max_len: None,
9868 min_val: Some(1),
9869 max_val: Some(250),
9870 enums: &[],
9871 },
9872 ],
9873 omembers: &[("targets", K::List), ("nextMarker", K::Str)],
9874 list_field: Some("targets"),
9875 list_elems: &[],
9876 list_scalar: true,
9877 req_payload: false,
9878 },
9879 OpMeta {
9880 op: "ListTargetsForSecurityProfile",
9881 method: "GET",
9882 segs: &[
9883 Seg::Fixed("security-profiles"),
9884 Seg::Label("securityProfileName"),
9885 Seg::Fixed("targets"),
9886 ],
9887 verb: Verb::List,
9888 rtype: "security-profiles",
9889 nlabels: 1,
9890 has_input: true,
9891 errors: &[
9892 "InternalFailureException",
9893 "InvalidRequestException",
9894 "ResourceNotFoundException",
9895 "ThrottlingException",
9896 ],
9897 rules: &[
9898 Rule {
9899 wire: "securityProfileName",
9900 src: Src::Label,
9901 req: true,
9902 kind: K::Str,
9903 min_len: Some(1),
9904 max_len: Some(128),
9905 min_val: None,
9906 max_val: None,
9907 enums: &[],
9908 },
9909 Rule {
9910 wire: "maxResults",
9911 src: Src::Query,
9912 req: false,
9913 kind: K::Int,
9914 min_len: None,
9915 max_len: None,
9916 min_val: Some(1),
9917 max_val: Some(250),
9918 enums: &[],
9919 },
9920 ],
9921 omembers: &[("securityProfileTargets", K::List), ("nextToken", K::Str)],
9922 list_field: Some("securityProfileTargets"),
9923 list_elems: &[("arn", K::Str)],
9924 list_scalar: false,
9925 req_payload: false,
9926 },
9927 OpMeta {
9928 op: "ListThingGroups",
9929 method: "GET",
9930 segs: &[Seg::Fixed("thing-groups")],
9931 verb: Verb::List,
9932 rtype: "thing-groups",
9933 nlabels: 0,
9934 has_input: true,
9935 errors: &[
9936 "InternalFailureException",
9937 "InvalidRequestException",
9938 "ResourceNotFoundException",
9939 "ThrottlingException",
9940 ],
9941 rules: &[
9942 Rule {
9943 wire: "maxResults",
9944 src: Src::Query,
9945 req: false,
9946 kind: K::Int,
9947 min_len: None,
9948 max_len: None,
9949 min_val: Some(1),
9950 max_val: Some(250),
9951 enums: &[],
9952 },
9953 Rule {
9954 wire: "parentGroup",
9955 src: Src::Query,
9956 req: false,
9957 kind: K::Str,
9958 min_len: Some(1),
9959 max_len: Some(128),
9960 min_val: None,
9961 max_val: None,
9962 enums: &[],
9963 },
9964 Rule {
9965 wire: "namePrefixFilter",
9966 src: Src::Query,
9967 req: false,
9968 kind: K::Str,
9969 min_len: Some(1),
9970 max_len: Some(128),
9971 min_val: None,
9972 max_val: None,
9973 enums: &[],
9974 },
9975 ],
9976 omembers: &[("thingGroups", K::List), ("nextToken", K::Str)],
9977 list_field: Some("thingGroups"),
9978 list_elems: &[("groupName", K::Str), ("groupArn", K::Str)],
9979 list_scalar: false,
9980 req_payload: false,
9981 },
9982 OpMeta {
9983 op: "ListThingGroupsForThing",
9984 method: "GET",
9985 segs: &[
9986 Seg::Fixed("things"),
9987 Seg::Label("thingName"),
9988 Seg::Fixed("thing-groups"),
9989 ],
9990 verb: Verb::List,
9991 rtype: "things",
9992 nlabels: 1,
9993 has_input: true,
9994 errors: &[
9995 "InternalFailureException",
9996 "InvalidRequestException",
9997 "ResourceNotFoundException",
9998 "ThrottlingException",
9999 ],
10000 rules: &[
10001 Rule {
10002 wire: "thingName",
10003 src: Src::Label,
10004 req: true,
10005 kind: K::Str,
10006 min_len: Some(1),
10007 max_len: Some(128),
10008 min_val: None,
10009 max_val: None,
10010 enums: &[],
10011 },
10012 Rule {
10013 wire: "maxResults",
10014 src: Src::Query,
10015 req: false,
10016 kind: K::Int,
10017 min_len: None,
10018 max_len: None,
10019 min_val: Some(1),
10020 max_val: Some(250),
10021 enums: &[],
10022 },
10023 ],
10024 omembers: &[("thingGroups", K::List), ("nextToken", K::Str)],
10025 list_field: Some("thingGroups"),
10026 list_elems: &[("groupName", K::Str), ("groupArn", K::Str)],
10027 list_scalar: false,
10028 req_payload: false,
10029 },
10030 OpMeta {
10031 op: "ListThingPrincipals",
10032 method: "GET",
10033 segs: &[
10034 Seg::Fixed("things"),
10035 Seg::Label("thingName"),
10036 Seg::Fixed("principals"),
10037 ],
10038 verb: Verb::List,
10039 rtype: "things",
10040 nlabels: 1,
10041 has_input: true,
10042 errors: &[
10043 "InternalFailureException",
10044 "InvalidRequestException",
10045 "ResourceNotFoundException",
10046 "ServiceUnavailableException",
10047 "ThrottlingException",
10048 "UnauthorizedException",
10049 ],
10050 rules: &[
10051 Rule {
10052 wire: "maxResults",
10053 src: Src::Query,
10054 req: false,
10055 kind: K::Int,
10056 min_len: None,
10057 max_len: None,
10058 min_val: Some(1),
10059 max_val: Some(250),
10060 enums: &[],
10061 },
10062 Rule {
10063 wire: "thingName",
10064 src: Src::Label,
10065 req: true,
10066 kind: K::Str,
10067 min_len: Some(1),
10068 max_len: Some(128),
10069 min_val: None,
10070 max_val: None,
10071 enums: &[],
10072 },
10073 ],
10074 omembers: &[("principals", K::List), ("nextToken", K::Str)],
10075 list_field: Some("principals"),
10076 list_elems: &[],
10077 list_scalar: true,
10078 req_payload: false,
10079 },
10080 OpMeta {
10081 op: "ListThingPrincipalsV2",
10082 method: "GET",
10083 segs: &[
10084 Seg::Fixed("things"),
10085 Seg::Label("thingName"),
10086 Seg::Fixed("principals-v2"),
10087 ],
10088 verb: Verb::List,
10089 rtype: "things",
10090 nlabels: 1,
10091 has_input: true,
10092 errors: &[
10093 "InternalFailureException",
10094 "InvalidRequestException",
10095 "ResourceNotFoundException",
10096 "ServiceUnavailableException",
10097 "ThrottlingException",
10098 "UnauthorizedException",
10099 ],
10100 rules: &[
10101 Rule {
10102 wire: "maxResults",
10103 src: Src::Query,
10104 req: false,
10105 kind: K::Int,
10106 min_len: None,
10107 max_len: None,
10108 min_val: Some(1),
10109 max_val: Some(250),
10110 enums: &[],
10111 },
10112 Rule {
10113 wire: "thingName",
10114 src: Src::Label,
10115 req: true,
10116 kind: K::Str,
10117 min_len: Some(1),
10118 max_len: Some(128),
10119 min_val: None,
10120 max_val: None,
10121 enums: &[],
10122 },
10123 Rule {
10124 wire: "thingPrincipalType",
10125 src: Src::Query,
10126 req: false,
10127 kind: K::Str,
10128 min_len: None,
10129 max_len: None,
10130 min_val: None,
10131 max_val: None,
10132 enums: &["EXCLUSIVE_THING", "NON_EXCLUSIVE_THING"],
10133 },
10134 ],
10135 omembers: &[("thingPrincipalObjects", K::List), ("nextToken", K::Str)],
10136 list_field: Some("thingPrincipalObjects"),
10137 list_elems: &[("principal", K::Str), ("thingPrincipalType", K::Str)],
10138 list_scalar: false,
10139 req_payload: false,
10140 },
10141 OpMeta {
10142 op: "ListThingRegistrationTaskReports",
10143 method: "GET",
10144 segs: &[
10145 Seg::Fixed("thing-registration-tasks"),
10146 Seg::Label("taskId"),
10147 Seg::Fixed("reports"),
10148 ],
10149 verb: Verb::List,
10150 rtype: "thing-registration-tasks",
10151 nlabels: 1,
10152 has_input: true,
10153 errors: &[
10154 "InternalFailureException",
10155 "InvalidRequestException",
10156 "ThrottlingException",
10157 "UnauthorizedException",
10158 ],
10159 rules: &[
10160 Rule {
10161 wire: "taskId",
10162 src: Src::Label,
10163 req: true,
10164 kind: K::Str,
10165 min_len: Some(0),
10166 max_len: Some(40),
10167 min_val: None,
10168 max_val: None,
10169 enums: &[],
10170 },
10171 Rule {
10172 wire: "reportType",
10173 src: Src::Query,
10174 req: true,
10175 kind: K::Str,
10176 min_len: None,
10177 max_len: None,
10178 min_val: None,
10179 max_val: None,
10180 enums: &["ERRORS", "RESULTS"],
10181 },
10182 Rule {
10183 wire: "maxResults",
10184 src: Src::Query,
10185 req: false,
10186 kind: K::Int,
10187 min_len: None,
10188 max_len: None,
10189 min_val: Some(1),
10190 max_val: Some(250),
10191 enums: &[],
10192 },
10193 ],
10194 omembers: &[
10195 ("resourceLinks", K::List),
10196 ("reportType", K::Str),
10197 ("nextToken", K::Str),
10198 ],
10199 list_field: Some("resourceLinks"),
10200 list_elems: &[],
10201 list_scalar: true,
10202 req_payload: false,
10203 },
10204 OpMeta {
10205 op: "ListThingRegistrationTasks",
10206 method: "GET",
10207 segs: &[Seg::Fixed("thing-registration-tasks")],
10208 verb: Verb::List,
10209 rtype: "thing-registration-tasks",
10210 nlabels: 0,
10211 has_input: true,
10212 errors: &[
10213 "InternalFailureException",
10214 "InvalidRequestException",
10215 "ThrottlingException",
10216 "UnauthorizedException",
10217 ],
10218 rules: &[
10219 Rule {
10220 wire: "maxResults",
10221 src: Src::Query,
10222 req: false,
10223 kind: K::Int,
10224 min_len: None,
10225 max_len: None,
10226 min_val: Some(1),
10227 max_val: Some(250),
10228 enums: &[],
10229 },
10230 Rule {
10231 wire: "status",
10232 src: Src::Query,
10233 req: false,
10234 kind: K::Str,
10235 min_len: None,
10236 max_len: None,
10237 min_val: None,
10238 max_val: None,
10239 enums: &[
10240 "InProgress",
10241 "Completed",
10242 "Failed",
10243 "Cancelled",
10244 "Cancelling",
10245 ],
10246 },
10247 ],
10248 omembers: &[("taskIds", K::List), ("nextToken", K::Str)],
10249 list_field: Some("taskIds"),
10250 list_elems: &[],
10251 list_scalar: true,
10252 req_payload: false,
10253 },
10254 OpMeta {
10255 op: "ListThingTypes",
10256 method: "GET",
10257 segs: &[Seg::Fixed("thing-types")],
10258 verb: Verb::List,
10259 rtype: "thing-types",
10260 nlabels: 0,
10261 has_input: true,
10262 errors: &[
10263 "InternalFailureException",
10264 "InvalidRequestException",
10265 "ServiceUnavailableException",
10266 "ThrottlingException",
10267 "UnauthorizedException",
10268 ],
10269 rules: &[
10270 Rule {
10271 wire: "maxResults",
10272 src: Src::Query,
10273 req: false,
10274 kind: K::Int,
10275 min_len: None,
10276 max_len: None,
10277 min_val: Some(1),
10278 max_val: Some(250),
10279 enums: &[],
10280 },
10281 Rule {
10282 wire: "thingTypeName",
10283 src: Src::Query,
10284 req: false,
10285 kind: K::Str,
10286 min_len: Some(1),
10287 max_len: Some(128),
10288 min_val: None,
10289 max_val: None,
10290 enums: &[],
10291 },
10292 ],
10293 omembers: &[("thingTypes", K::List), ("nextToken", K::Str)],
10294 list_field: Some("thingTypes"),
10295 list_elems: &[
10296 ("thingTypeName", K::Str),
10297 ("thingTypeArn", K::Str),
10298 ("thingTypeProperties", K::Struct),
10299 ("thingTypeMetadata", K::Struct),
10300 ],
10301 list_scalar: false,
10302 req_payload: false,
10303 },
10304 OpMeta {
10305 op: "ListThings",
10306 method: "GET",
10307 segs: &[Seg::Fixed("things")],
10308 verb: Verb::List,
10309 rtype: "things",
10310 nlabels: 0,
10311 has_input: true,
10312 errors: &[
10313 "InternalFailureException",
10314 "InvalidRequestException",
10315 "ServiceUnavailableException",
10316 "ThrottlingException",
10317 "UnauthorizedException",
10318 ],
10319 rules: &[
10320 Rule {
10321 wire: "maxResults",
10322 src: Src::Query,
10323 req: false,
10324 kind: K::Int,
10325 min_len: None,
10326 max_len: None,
10327 min_val: Some(1),
10328 max_val: Some(250),
10329 enums: &[],
10330 },
10331 Rule {
10332 wire: "attributeName",
10333 src: Src::Query,
10334 req: false,
10335 kind: K::Str,
10336 min_len: Some(0),
10337 max_len: Some(128),
10338 min_val: None,
10339 max_val: None,
10340 enums: &[],
10341 },
10342 Rule {
10343 wire: "attributeValue",
10344 src: Src::Query,
10345 req: false,
10346 kind: K::Str,
10347 min_len: Some(0),
10348 max_len: Some(800),
10349 min_val: None,
10350 max_val: None,
10351 enums: &[],
10352 },
10353 Rule {
10354 wire: "thingTypeName",
10355 src: Src::Query,
10356 req: false,
10357 kind: K::Str,
10358 min_len: Some(1),
10359 max_len: Some(128),
10360 min_val: None,
10361 max_val: None,
10362 enums: &[],
10363 },
10364 ],
10365 omembers: &[("things", K::List), ("nextToken", K::Str)],
10366 list_field: Some("things"),
10367 list_elems: &[
10368 ("thingName", K::Str),
10369 ("thingTypeName", K::Str),
10370 ("thingArn", K::Str),
10371 ("attributes", K::Map),
10372 ("version", K::Int),
10373 ],
10374 list_scalar: false,
10375 req_payload: false,
10376 },
10377 OpMeta {
10378 op: "ListThingsInBillingGroup",
10379 method: "GET",
10380 segs: &[
10381 Seg::Fixed("billing-groups"),
10382 Seg::Label("billingGroupName"),
10383 Seg::Fixed("things"),
10384 ],
10385 verb: Verb::List,
10386 rtype: "billing-groups",
10387 nlabels: 1,
10388 has_input: true,
10389 errors: &[
10390 "InternalFailureException",
10391 "InvalidRequestException",
10392 "ResourceNotFoundException",
10393 "ThrottlingException",
10394 ],
10395 rules: &[
10396 Rule {
10397 wire: "billingGroupName",
10398 src: Src::Label,
10399 req: true,
10400 kind: K::Str,
10401 min_len: Some(1),
10402 max_len: Some(128),
10403 min_val: None,
10404 max_val: None,
10405 enums: &[],
10406 },
10407 Rule {
10408 wire: "maxResults",
10409 src: Src::Query,
10410 req: false,
10411 kind: K::Int,
10412 min_len: None,
10413 max_len: None,
10414 min_val: Some(1),
10415 max_val: Some(250),
10416 enums: &[],
10417 },
10418 ],
10419 omembers: &[("things", K::List), ("nextToken", K::Str)],
10420 list_field: Some("things"),
10421 list_elems: &[],
10422 list_scalar: true,
10423 req_payload: false,
10424 },
10425 OpMeta {
10426 op: "ListThingsInThingGroup",
10427 method: "GET",
10428 segs: &[
10429 Seg::Fixed("thing-groups"),
10430 Seg::Label("thingGroupName"),
10431 Seg::Fixed("things"),
10432 ],
10433 verb: Verb::List,
10434 rtype: "thing-groups",
10435 nlabels: 1,
10436 has_input: true,
10437 errors: &[
10438 "InternalFailureException",
10439 "InvalidRequestException",
10440 "ResourceNotFoundException",
10441 "ThrottlingException",
10442 ],
10443 rules: &[
10444 Rule {
10445 wire: "thingGroupName",
10446 src: Src::Label,
10447 req: true,
10448 kind: K::Str,
10449 min_len: Some(1),
10450 max_len: Some(128),
10451 min_val: None,
10452 max_val: None,
10453 enums: &[],
10454 },
10455 Rule {
10456 wire: "maxResults",
10457 src: Src::Query,
10458 req: false,
10459 kind: K::Int,
10460 min_len: None,
10461 max_len: None,
10462 min_val: Some(1),
10463 max_val: Some(250),
10464 enums: &[],
10465 },
10466 ],
10467 omembers: &[("things", K::List), ("nextToken", K::Str)],
10468 list_field: Some("things"),
10469 list_elems: &[],
10470 list_scalar: true,
10471 req_payload: false,
10472 },
10473 OpMeta {
10474 op: "ListTopicRuleDestinations",
10475 method: "GET",
10476 segs: &[Seg::Fixed("destinations")],
10477 verb: Verb::List,
10478 rtype: "destinations",
10479 nlabels: 0,
10480 has_input: true,
10481 errors: &[
10482 "InternalException",
10483 "InvalidRequestException",
10484 "ServiceUnavailableException",
10485 "UnauthorizedException",
10486 ],
10487 rules: &[Rule {
10488 wire: "maxResults",
10489 src: Src::Query,
10490 req: false,
10491 kind: K::Int,
10492 min_len: None,
10493 max_len: None,
10494 min_val: Some(1),
10495 max_val: Some(1000),
10496 enums: &[],
10497 }],
10498 omembers: &[("destinationSummaries", K::List), ("nextToken", K::Str)],
10499 list_field: Some("destinationSummaries"),
10500 list_elems: &[
10501 ("arn", K::Str),
10502 ("status", K::Str),
10503 ("createdAt", K::Ts),
10504 ("lastUpdatedAt", K::Ts),
10505 ("statusReason", K::Str),
10506 ("httpUrlSummary", K::Struct),
10507 ("vpcDestinationSummary", K::Struct),
10508 ],
10509 list_scalar: false,
10510 req_payload: false,
10511 },
10512 OpMeta {
10513 op: "ListTopicRules",
10514 method: "GET",
10515 segs: &[Seg::Fixed("rules")],
10516 verb: Verb::List,
10517 rtype: "rules",
10518 nlabels: 0,
10519 has_input: true,
10520 errors: &[
10521 "InternalException",
10522 "InvalidRequestException",
10523 "ServiceUnavailableException",
10524 "UnauthorizedException",
10525 ],
10526 rules: &[Rule {
10527 wire: "maxResults",
10528 src: Src::Query,
10529 req: false,
10530 kind: K::Int,
10531 min_len: None,
10532 max_len: None,
10533 min_val: Some(1),
10534 max_val: Some(10000),
10535 enums: &[],
10536 }],
10537 omembers: &[("rules", K::List), ("nextToken", K::Str)],
10538 list_field: Some("rules"),
10539 list_elems: &[
10540 ("ruleArn", K::Str),
10541 ("ruleName", K::Str),
10542 ("topicPattern", K::Str),
10543 ("createdAt", K::Ts),
10544 ("ruleDisabled", K::Bool),
10545 ],
10546 list_scalar: false,
10547 req_payload: false,
10548 },
10549 OpMeta {
10550 op: "ListV2LoggingLevels",
10551 method: "GET",
10552 segs: &[Seg::Fixed("v2LoggingLevel")],
10553 verb: Verb::List,
10554 rtype: "v2LoggingLevel",
10555 nlabels: 0,
10556 has_input: true,
10557 errors: &[
10558 "InternalException",
10559 "InvalidRequestException",
10560 "NotConfiguredException",
10561 "ServiceUnavailableException",
10562 ],
10563 rules: &[
10564 Rule {
10565 wire: "targetType",
10566 src: Src::Query,
10567 req: false,
10568 kind: K::Str,
10569 min_len: None,
10570 max_len: None,
10571 min_val: None,
10572 max_val: None,
10573 enums: &[
10574 "DEFAULT",
10575 "THING_GROUP",
10576 "CLIENT_ID",
10577 "SOURCE_IP",
10578 "PRINCIPAL_ID",
10579 ],
10580 },
10581 Rule {
10582 wire: "maxResults",
10583 src: Src::Query,
10584 req: false,
10585 kind: K::Int,
10586 min_len: None,
10587 max_len: None,
10588 min_val: Some(1),
10589 max_val: Some(250),
10590 enums: &[],
10591 },
10592 ],
10593 omembers: &[("logTargetConfigurations", K::List), ("nextToken", K::Str)],
10594 list_field: Some("logTargetConfigurations"),
10595 list_elems: &[("logTarget", K::Struct), ("logLevel", K::Str)],
10596 list_scalar: false,
10597 req_payload: false,
10598 },
10599 OpMeta {
10600 op: "ListViolationEvents",
10601 method: "GET",
10602 segs: &[Seg::Fixed("violation-events")],
10603 verb: Verb::List,
10604 rtype: "violation-events",
10605 nlabels: 0,
10606 has_input: true,
10607 errors: &[
10608 "InternalFailureException",
10609 "InvalidRequestException",
10610 "ThrottlingException",
10611 ],
10612 rules: &[
10613 Rule {
10614 wire: "startTime",
10615 src: Src::Query,
10616 req: true,
10617 kind: K::Ts,
10618 min_len: None,
10619 max_len: None,
10620 min_val: None,
10621 max_val: None,
10622 enums: &[],
10623 },
10624 Rule {
10625 wire: "endTime",
10626 src: Src::Query,
10627 req: true,
10628 kind: K::Ts,
10629 min_len: None,
10630 max_len: None,
10631 min_val: None,
10632 max_val: None,
10633 enums: &[],
10634 },
10635 Rule {
10636 wire: "thingName",
10637 src: Src::Query,
10638 req: false,
10639 kind: K::Str,
10640 min_len: Some(1),
10641 max_len: Some(128),
10642 min_val: None,
10643 max_val: None,
10644 enums: &[],
10645 },
10646 Rule {
10647 wire: "securityProfileName",
10648 src: Src::Query,
10649 req: false,
10650 kind: K::Str,
10651 min_len: Some(1),
10652 max_len: Some(128),
10653 min_val: None,
10654 max_val: None,
10655 enums: &[],
10656 },
10657 Rule {
10658 wire: "behaviorCriteriaType",
10659 src: Src::Query,
10660 req: false,
10661 kind: K::Str,
10662 min_len: None,
10663 max_len: None,
10664 min_val: None,
10665 max_val: None,
10666 enums: &["STATIC", "STATISTICAL", "MACHINE_LEARNING"],
10667 },
10668 Rule {
10669 wire: "verificationState",
10670 src: Src::Query,
10671 req: false,
10672 kind: K::Str,
10673 min_len: None,
10674 max_len: None,
10675 min_val: None,
10676 max_val: None,
10677 enums: &[
10678 "FALSE_POSITIVE",
10679 "BENIGN_POSITIVE",
10680 "TRUE_POSITIVE",
10681 "UNKNOWN",
10682 ],
10683 },
10684 Rule {
10685 wire: "maxResults",
10686 src: Src::Query,
10687 req: false,
10688 kind: K::Int,
10689 min_len: None,
10690 max_len: None,
10691 min_val: Some(1),
10692 max_val: Some(250),
10693 enums: &[],
10694 },
10695 ],
10696 omembers: &[("violationEvents", K::List), ("nextToken", K::Str)],
10697 list_field: Some("violationEvents"),
10698 list_elems: &[
10699 ("violationId", K::Str),
10700 ("thingName", K::Str),
10701 ("securityProfileName", K::Str),
10702 ("behavior", K::Struct),
10703 ("metricValue", K::Struct),
10704 ("violationEventAdditionalInfo", K::Struct),
10705 ("violationEventType", K::Str),
10706 ("verificationState", K::Str),
10707 ("verificationStateDescription", K::Str),
10708 ("violationEventTime", K::Ts),
10709 ],
10710 list_scalar: false,
10711 req_payload: false,
10712 },
10713 OpMeta {
10714 op: "PutVerificationStateOnViolation",
10715 method: "POST",
10716 segs: &[
10717 Seg::Fixed("violations"),
10718 Seg::Fixed("verification-state"),
10719 Seg::Label("violationId"),
10720 ],
10721 verb: Verb::Action,
10722 rtype: "violations",
10723 nlabels: 1,
10724 has_input: true,
10725 errors: &[
10726 "InternalFailureException",
10727 "InvalidRequestException",
10728 "ThrottlingException",
10729 ],
10730 rules: &[
10731 Rule {
10732 wire: "violationId",
10733 src: Src::Label,
10734 req: true,
10735 kind: K::Str,
10736 min_len: Some(1),
10737 max_len: Some(128),
10738 min_val: None,
10739 max_val: None,
10740 enums: &[],
10741 },
10742 Rule {
10743 wire: "verificationState",
10744 src: Src::Body,
10745 req: true,
10746 kind: K::Str,
10747 min_len: None,
10748 max_len: None,
10749 min_val: None,
10750 max_val: None,
10751 enums: &[
10752 "FALSE_POSITIVE",
10753 "BENIGN_POSITIVE",
10754 "TRUE_POSITIVE",
10755 "UNKNOWN",
10756 ],
10757 },
10758 Rule {
10759 wire: "verificationStateDescription",
10760 src: Src::Body,
10761 req: false,
10762 kind: K::Str,
10763 min_len: Some(0),
10764 max_len: Some(1000),
10765 min_val: None,
10766 max_val: None,
10767 enums: &[],
10768 },
10769 ],
10770 omembers: &[],
10771 list_field: None,
10772 list_elems: &[],
10773 list_scalar: false,
10774 req_payload: false,
10775 },
10776 OpMeta {
10777 op: "RegisterCACertificate",
10778 method: "POST",
10779 segs: &[Seg::Fixed("cacertificate")],
10780 verb: Verb::Action,
10781 rtype: "cacertificate",
10782 nlabels: 0,
10783 has_input: true,
10784 errors: &[
10785 "CertificateValidationException",
10786 "InternalFailureException",
10787 "InvalidRequestException",
10788 "LimitExceededException",
10789 "RegistrationCodeValidationException",
10790 "ResourceAlreadyExistsException",
10791 "ResourceNotFoundException",
10792 "ServiceUnavailableException",
10793 "ThrottlingException",
10794 "UnauthorizedException",
10795 ],
10796 rules: &[
10797 Rule {
10798 wire: "caCertificate",
10799 src: Src::Body,
10800 req: true,
10801 kind: K::Str,
10802 min_len: Some(1),
10803 max_len: Some(65536),
10804 min_val: None,
10805 max_val: None,
10806 enums: &[],
10807 },
10808 Rule {
10809 wire: "verificationCertificate",
10810 src: Src::Body,
10811 req: false,
10812 kind: K::Str,
10813 min_len: Some(1),
10814 max_len: Some(65536),
10815 min_val: None,
10816 max_val: None,
10817 enums: &[],
10818 },
10819 Rule {
10820 wire: "certificateMode",
10821 src: Src::Body,
10822 req: false,
10823 kind: K::Str,
10824 min_len: None,
10825 max_len: None,
10826 min_val: None,
10827 max_val: None,
10828 enums: &["DEFAULT", "SNI_ONLY"],
10829 },
10830 ],
10831 omembers: &[("certificateArn", K::Str), ("certificateId", K::Str)],
10832 list_field: None,
10833 list_elems: &[],
10834 list_scalar: false,
10835 req_payload: false,
10836 },
10837 OpMeta {
10838 op: "RegisterCertificate",
10839 method: "POST",
10840 segs: &[Seg::Fixed("certificate"), Seg::Fixed("register")],
10841 verb: Verb::Action,
10842 rtype: "certificate",
10843 nlabels: 0,
10844 has_input: true,
10845 errors: &[
10846 "CertificateConflictException",
10847 "CertificateStateException",
10848 "CertificateValidationException",
10849 "InternalFailureException",
10850 "InvalidRequestException",
10851 "ResourceAlreadyExistsException",
10852 "ServiceUnavailableException",
10853 "ThrottlingException",
10854 "UnauthorizedException",
10855 ],
10856 rules: &[
10857 Rule {
10858 wire: "certificatePem",
10859 src: Src::Body,
10860 req: true,
10861 kind: K::Str,
10862 min_len: Some(1),
10863 max_len: Some(65536),
10864 min_val: None,
10865 max_val: None,
10866 enums: &[],
10867 },
10868 Rule {
10869 wire: "caCertificatePem",
10870 src: Src::Body,
10871 req: false,
10872 kind: K::Str,
10873 min_len: Some(1),
10874 max_len: Some(65536),
10875 min_val: None,
10876 max_val: None,
10877 enums: &[],
10878 },
10879 Rule {
10880 wire: "status",
10881 src: Src::Body,
10882 req: false,
10883 kind: K::Str,
10884 min_len: None,
10885 max_len: None,
10886 min_val: None,
10887 max_val: None,
10888 enums: &[
10889 "ACTIVE",
10890 "INACTIVE",
10891 "REVOKED",
10892 "PENDING_TRANSFER",
10893 "REGISTER_INACTIVE",
10894 "PENDING_ACTIVATION",
10895 ],
10896 },
10897 ],
10898 omembers: &[("certificateArn", K::Str), ("certificateId", K::Str)],
10899 list_field: None,
10900 list_elems: &[],
10901 list_scalar: false,
10902 req_payload: false,
10903 },
10904 OpMeta {
10905 op: "RegisterCertificateWithoutCA",
10906 method: "POST",
10907 segs: &[Seg::Fixed("certificate"), Seg::Fixed("register-no-ca")],
10908 verb: Verb::Action,
10909 rtype: "certificate",
10910 nlabels: 0,
10911 has_input: true,
10912 errors: &[
10913 "CertificateStateException",
10914 "CertificateValidationException",
10915 "InternalFailureException",
10916 "InvalidRequestException",
10917 "ResourceAlreadyExistsException",
10918 "ServiceUnavailableException",
10919 "ThrottlingException",
10920 "UnauthorizedException",
10921 ],
10922 rules: &[
10923 Rule {
10924 wire: "certificatePem",
10925 src: Src::Body,
10926 req: true,
10927 kind: K::Str,
10928 min_len: Some(1),
10929 max_len: Some(65536),
10930 min_val: None,
10931 max_val: None,
10932 enums: &[],
10933 },
10934 Rule {
10935 wire: "status",
10936 src: Src::Body,
10937 req: false,
10938 kind: K::Str,
10939 min_len: None,
10940 max_len: None,
10941 min_val: None,
10942 max_val: None,
10943 enums: &[
10944 "ACTIVE",
10945 "INACTIVE",
10946 "REVOKED",
10947 "PENDING_TRANSFER",
10948 "REGISTER_INACTIVE",
10949 "PENDING_ACTIVATION",
10950 ],
10951 },
10952 ],
10953 omembers: &[("certificateArn", K::Str), ("certificateId", K::Str)],
10954 list_field: None,
10955 list_elems: &[],
10956 list_scalar: false,
10957 req_payload: false,
10958 },
10959 OpMeta {
10960 op: "RegisterThing",
10961 method: "POST",
10962 segs: &[Seg::Fixed("things")],
10963 verb: Verb::Action,
10964 rtype: "things",
10965 nlabels: 0,
10966 has_input: true,
10967 errors: &[
10968 "ConflictingResourceUpdateException",
10969 "InternalFailureException",
10970 "InvalidRequestException",
10971 "ResourceRegistrationFailureException",
10972 "ServiceUnavailableException",
10973 "ThrottlingException",
10974 "UnauthorizedException",
10975 ],
10976 rules: &[Rule {
10977 wire: "templateBody",
10978 src: Src::Body,
10979 req: true,
10980 kind: K::Str,
10981 min_len: Some(0),
10982 max_len: Some(10240),
10983 min_val: None,
10984 max_val: None,
10985 enums: &[],
10986 }],
10987 omembers: &[("certificatePem", K::Str), ("resourceArns", K::Map)],
10988 list_field: None,
10989 list_elems: &[],
10990 list_scalar: false,
10991 req_payload: false,
10992 },
10993 OpMeta {
10994 op: "RejectCertificateTransfer",
10995 method: "PATCH",
10996 segs: &[
10997 Seg::Fixed("reject-certificate-transfer"),
10998 Seg::Label("certificateId"),
10999 ],
11000 verb: Verb::Action,
11001 rtype: "reject-certificate-transfer",
11002 nlabels: 1,
11003 has_input: true,
11004 errors: &[
11005 "InternalFailureException",
11006 "InvalidRequestException",
11007 "ResourceNotFoundException",
11008 "ServiceUnavailableException",
11009 "ThrottlingException",
11010 "TransferAlreadyCompletedException",
11011 "UnauthorizedException",
11012 ],
11013 rules: &[
11014 Rule {
11015 wire: "certificateId",
11016 src: Src::Label,
11017 req: true,
11018 kind: K::Str,
11019 min_len: Some(64),
11020 max_len: Some(64),
11021 min_val: None,
11022 max_val: None,
11023 enums: &[],
11024 },
11025 Rule {
11026 wire: "rejectReason",
11027 src: Src::Body,
11028 req: false,
11029 kind: K::Str,
11030 min_len: Some(0),
11031 max_len: Some(128),
11032 min_val: None,
11033 max_val: None,
11034 enums: &[],
11035 },
11036 ],
11037 omembers: &[],
11038 list_field: None,
11039 list_elems: &[],
11040 list_scalar: false,
11041 req_payload: false,
11042 },
11043 OpMeta {
11044 op: "RemoveThingFromBillingGroup",
11045 method: "PUT",
11046 segs: &[
11047 Seg::Fixed("billing-groups"),
11048 Seg::Fixed("removeThingFromBillingGroup"),
11049 ],
11050 verb: Verb::Action,
11051 rtype: "billing-groups",
11052 nlabels: 0,
11053 has_input: true,
11054 errors: &[
11055 "InternalFailureException",
11056 "InvalidRequestException",
11057 "ResourceNotFoundException",
11058 "ThrottlingException",
11059 ],
11060 rules: &[
11061 Rule {
11062 wire: "billingGroupName",
11063 src: Src::Body,
11064 req: false,
11065 kind: K::Str,
11066 min_len: Some(1),
11067 max_len: Some(128),
11068 min_val: None,
11069 max_val: None,
11070 enums: &[],
11071 },
11072 Rule {
11073 wire: "thingName",
11074 src: Src::Body,
11075 req: false,
11076 kind: K::Str,
11077 min_len: Some(1),
11078 max_len: Some(128),
11079 min_val: None,
11080 max_val: None,
11081 enums: &[],
11082 },
11083 ],
11084 omembers: &[],
11085 list_field: None,
11086 list_elems: &[],
11087 list_scalar: false,
11088 req_payload: false,
11089 },
11090 OpMeta {
11091 op: "RemoveThingFromThingGroup",
11092 method: "PUT",
11093 segs: &[
11094 Seg::Fixed("thing-groups"),
11095 Seg::Fixed("removeThingFromThingGroup"),
11096 ],
11097 verb: Verb::Action,
11098 rtype: "thing-groups",
11099 nlabels: 0,
11100 has_input: true,
11101 errors: &[
11102 "InternalFailureException",
11103 "InvalidRequestException",
11104 "ResourceNotFoundException",
11105 "ThrottlingException",
11106 ],
11107 rules: &[
11108 Rule {
11109 wire: "thingGroupName",
11110 src: Src::Body,
11111 req: false,
11112 kind: K::Str,
11113 min_len: Some(1),
11114 max_len: Some(128),
11115 min_val: None,
11116 max_val: None,
11117 enums: &[],
11118 },
11119 Rule {
11120 wire: "thingName",
11121 src: Src::Body,
11122 req: false,
11123 kind: K::Str,
11124 min_len: Some(1),
11125 max_len: Some(128),
11126 min_val: None,
11127 max_val: None,
11128 enums: &[],
11129 },
11130 ],
11131 omembers: &[],
11132 list_field: None,
11133 list_elems: &[],
11134 list_scalar: false,
11135 req_payload: false,
11136 },
11137 OpMeta {
11138 op: "ReplaceTopicRule",
11139 method: "PATCH",
11140 segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
11141 verb: Verb::Action,
11142 rtype: "rules",
11143 nlabels: 1,
11144 has_input: true,
11145 errors: &[
11146 "ConflictingResourceUpdateException",
11147 "InternalException",
11148 "InvalidRequestException",
11149 "ServiceUnavailableException",
11150 "SqlParseException",
11151 "UnauthorizedException",
11152 ],
11153 rules: &[Rule {
11154 wire: "ruleName",
11155 src: Src::Label,
11156 req: true,
11157 kind: K::Str,
11158 min_len: Some(1),
11159 max_len: Some(128),
11160 min_val: None,
11161 max_val: None,
11162 enums: &[],
11163 }],
11164 omembers: &[],
11165 list_field: None,
11166 list_elems: &[],
11167 list_scalar: false,
11168 req_payload: true,
11169 },
11170 OpMeta {
11171 op: "SearchIndex",
11172 method: "POST",
11173 segs: &[Seg::Fixed("indices"), Seg::Fixed("search")],
11174 verb: Verb::Action,
11175 rtype: "indices",
11176 nlabels: 0,
11177 has_input: true,
11178 errors: &[
11179 "IndexNotReadyException",
11180 "InternalFailureException",
11181 "InvalidQueryException",
11182 "InvalidRequestException",
11183 "ResourceNotFoundException",
11184 "ServiceUnavailableException",
11185 "ThrottlingException",
11186 "UnauthorizedException",
11187 ],
11188 rules: &[
11189 Rule {
11190 wire: "indexName",
11191 src: Src::Body,
11192 req: false,
11193 kind: K::Str,
11194 min_len: Some(1),
11195 max_len: Some(128),
11196 min_val: None,
11197 max_val: None,
11198 enums: &[],
11199 },
11200 Rule {
11201 wire: "queryString",
11202 src: Src::Body,
11203 req: true,
11204 kind: K::Str,
11205 min_len: Some(1),
11206 max_len: None,
11207 min_val: None,
11208 max_val: None,
11209 enums: &[],
11210 },
11211 Rule {
11212 wire: "maxResults",
11213 src: Src::Body,
11214 req: false,
11215 kind: K::Int,
11216 min_len: None,
11217 max_len: None,
11218 min_val: Some(1),
11219 max_val: None,
11220 enums: &[],
11221 },
11222 ],
11223 omembers: &[
11224 ("nextToken", K::Str),
11225 ("things", K::List),
11226 ("thingGroups", K::List),
11227 ],
11228 list_field: Some("things"),
11229 list_elems: &[
11230 ("thingName", K::Str),
11231 ("thingId", K::Str),
11232 ("thingTypeName", K::Str),
11233 ("thingGroupNames", K::List),
11234 ("attributes", K::Map),
11235 ("shadow", K::Str),
11236 ("deviceDefender", K::Str),
11237 ("connectivity", K::Struct),
11238 ],
11239 list_scalar: false,
11240 req_payload: false,
11241 },
11242 OpMeta {
11243 op: "SetDefaultAuthorizer",
11244 method: "POST",
11245 segs: &[Seg::Fixed("default-authorizer")],
11246 verb: Verb::Action,
11247 rtype: "default-authorizer",
11248 nlabels: 0,
11249 has_input: true,
11250 errors: &[
11251 "InternalFailureException",
11252 "InvalidRequestException",
11253 "ResourceAlreadyExistsException",
11254 "ResourceNotFoundException",
11255 "ServiceUnavailableException",
11256 "ThrottlingException",
11257 "UnauthorizedException",
11258 ],
11259 rules: &[Rule {
11260 wire: "authorizerName",
11261 src: Src::Body,
11262 req: true,
11263 kind: K::Str,
11264 min_len: Some(1),
11265 max_len: Some(128),
11266 min_val: None,
11267 max_val: None,
11268 enums: &[],
11269 }],
11270 omembers: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
11271 list_field: None,
11272 list_elems: &[],
11273 list_scalar: false,
11274 req_payload: false,
11275 },
11276 OpMeta {
11277 op: "SetDefaultPolicyVersion",
11278 method: "PATCH",
11279 segs: &[
11280 Seg::Fixed("policies"),
11281 Seg::Label("policyName"),
11282 Seg::Fixed("version"),
11283 Seg::Label("policyVersionId"),
11284 ],
11285 verb: Verb::Action,
11286 rtype: "policies",
11287 nlabels: 2,
11288 has_input: true,
11289 errors: &[
11290 "InternalFailureException",
11291 "InvalidRequestException",
11292 "ResourceNotFoundException",
11293 "ServiceUnavailableException",
11294 "ThrottlingException",
11295 "UnauthorizedException",
11296 ],
11297 rules: &[
11298 Rule {
11299 wire: "policyName",
11300 src: Src::Label,
11301 req: true,
11302 kind: K::Str,
11303 min_len: Some(1),
11304 max_len: Some(128),
11305 min_val: None,
11306 max_val: None,
11307 enums: &[],
11308 },
11309 Rule {
11310 wire: "policyVersionId",
11311 src: Src::Label,
11312 req: true,
11313 kind: K::Str,
11314 min_len: None,
11315 max_len: None,
11316 min_val: None,
11317 max_val: None,
11318 enums: &[],
11319 },
11320 ],
11321 omembers: &[],
11322 list_field: None,
11323 list_elems: &[],
11324 list_scalar: false,
11325 req_payload: false,
11326 },
11327 OpMeta {
11328 op: "SetLoggingOptions",
11329 method: "POST",
11330 segs: &[Seg::Fixed("loggingOptions")],
11331 verb: Verb::Action,
11332 rtype: "loggingOptions",
11333 nlabels: 0,
11334 has_input: true,
11335 errors: &[
11336 "InternalException",
11337 "InvalidRequestException",
11338 "ServiceUnavailableException",
11339 ],
11340 rules: &[],
11341 omembers: &[],
11342 list_field: None,
11343 list_elems: &[],
11344 list_scalar: false,
11345 req_payload: true,
11346 },
11347 OpMeta {
11348 op: "SetV2LoggingLevel",
11349 method: "POST",
11350 segs: &[Seg::Fixed("v2LoggingLevel")],
11351 verb: Verb::Action,
11352 rtype: "v2LoggingLevel",
11353 nlabels: 0,
11354 has_input: true,
11355 errors: &[
11356 "InternalException",
11357 "InvalidRequestException",
11358 "LimitExceededException",
11359 "NotConfiguredException",
11360 "ServiceUnavailableException",
11361 ],
11362 rules: &[
11363 Rule {
11364 wire: "logTarget",
11365 src: Src::Body,
11366 req: true,
11367 kind: K::Struct,
11368 min_len: None,
11369 max_len: None,
11370 min_val: None,
11371 max_val: None,
11372 enums: &[],
11373 },
11374 Rule {
11375 wire: "logLevel",
11376 src: Src::Body,
11377 req: true,
11378 kind: K::Str,
11379 min_len: None,
11380 max_len: None,
11381 min_val: None,
11382 max_val: None,
11383 enums: &["DEBUG", "INFO", "ERROR", "WARN", "DISABLED"],
11384 },
11385 ],
11386 omembers: &[],
11387 list_field: None,
11388 list_elems: &[],
11389 list_scalar: false,
11390 req_payload: false,
11391 },
11392 OpMeta {
11393 op: "SetV2LoggingOptions",
11394 method: "POST",
11395 segs: &[Seg::Fixed("v2LoggingOptions")],
11396 verb: Verb::Action,
11397 rtype: "v2LoggingOptions",
11398 nlabels: 0,
11399 has_input: true,
11400 errors: &[
11401 "InternalException",
11402 "InvalidRequestException",
11403 "ServiceUnavailableException",
11404 ],
11405 rules: &[Rule {
11406 wire: "defaultLogLevel",
11407 src: Src::Body,
11408 req: false,
11409 kind: K::Str,
11410 min_len: None,
11411 max_len: None,
11412 min_val: None,
11413 max_val: None,
11414 enums: &["DEBUG", "INFO", "ERROR", "WARN", "DISABLED"],
11415 }],
11416 omembers: &[],
11417 list_field: None,
11418 list_elems: &[],
11419 list_scalar: false,
11420 req_payload: false,
11421 },
11422 OpMeta {
11423 op: "StartAuditMitigationActionsTask",
11424 method: "POST",
11425 segs: &[
11426 Seg::Fixed("audit"),
11427 Seg::Fixed("mitigationactions"),
11428 Seg::Fixed("tasks"),
11429 Seg::Label("taskId"),
11430 ],
11431 verb: Verb::Action,
11432 rtype: "audit",
11433 nlabels: 1,
11434 has_input: true,
11435 errors: &[
11436 "InternalFailureException",
11437 "InvalidRequestException",
11438 "LimitExceededException",
11439 "TaskAlreadyExistsException",
11440 "ThrottlingException",
11441 ],
11442 rules: &[
11443 Rule {
11444 wire: "taskId",
11445 src: Src::Label,
11446 req: true,
11447 kind: K::Str,
11448 min_len: Some(1),
11449 max_len: Some(128),
11450 min_val: None,
11451 max_val: None,
11452 enums: &[],
11453 },
11454 Rule {
11455 wire: "target",
11456 src: Src::Body,
11457 req: true,
11458 kind: K::Struct,
11459 min_len: None,
11460 max_len: None,
11461 min_val: None,
11462 max_val: None,
11463 enums: &[],
11464 },
11465 Rule {
11466 wire: "auditCheckToActionsMapping",
11467 src: Src::Body,
11468 req: true,
11469 kind: K::Map,
11470 min_len: None,
11471 max_len: None,
11472 min_val: None,
11473 max_val: None,
11474 enums: &[],
11475 },
11476 Rule {
11477 wire: "clientRequestToken",
11478 src: Src::Body,
11479 req: true,
11480 kind: K::Str,
11481 min_len: Some(1),
11482 max_len: Some(64),
11483 min_val: None,
11484 max_val: None,
11485 enums: &[],
11486 },
11487 ],
11488 omembers: &[("taskId", K::Str)],
11489 list_field: None,
11490 list_elems: &[],
11491 list_scalar: false,
11492 req_payload: false,
11493 },
11494 OpMeta {
11495 op: "StartDetectMitigationActionsTask",
11496 method: "PUT",
11497 segs: &[
11498 Seg::Fixed("detect"),
11499 Seg::Fixed("mitigationactions"),
11500 Seg::Fixed("tasks"),
11501 Seg::Label("taskId"),
11502 ],
11503 verb: Verb::Action,
11504 rtype: "detect",
11505 nlabels: 1,
11506 has_input: true,
11507 errors: &[
11508 "InternalFailureException",
11509 "InvalidRequestException",
11510 "LimitExceededException",
11511 "TaskAlreadyExistsException",
11512 "ThrottlingException",
11513 ],
11514 rules: &[
11515 Rule {
11516 wire: "taskId",
11517 src: Src::Label,
11518 req: true,
11519 kind: K::Str,
11520 min_len: Some(1),
11521 max_len: Some(128),
11522 min_val: None,
11523 max_val: None,
11524 enums: &[],
11525 },
11526 Rule {
11527 wire: "target",
11528 src: Src::Body,
11529 req: true,
11530 kind: K::Struct,
11531 min_len: None,
11532 max_len: None,
11533 min_val: None,
11534 max_val: None,
11535 enums: &[],
11536 },
11537 Rule {
11538 wire: "actions",
11539 src: Src::Body,
11540 req: true,
11541 kind: K::List,
11542 min_len: Some(1),
11543 max_len: Some(5),
11544 min_val: None,
11545 max_val: None,
11546 enums: &[],
11547 },
11548 Rule {
11549 wire: "clientRequestToken",
11550 src: Src::Body,
11551 req: true,
11552 kind: K::Str,
11553 min_len: Some(1),
11554 max_len: Some(64),
11555 min_val: None,
11556 max_val: None,
11557 enums: &[],
11558 },
11559 ],
11560 omembers: &[("taskId", K::Str)],
11561 list_field: None,
11562 list_elems: &[],
11563 list_scalar: false,
11564 req_payload: false,
11565 },
11566 OpMeta {
11567 op: "StartOnDemandAuditTask",
11568 method: "POST",
11569 segs: &[Seg::Fixed("audit"), Seg::Fixed("tasks")],
11570 verb: Verb::Action,
11571 rtype: "audit",
11572 nlabels: 0,
11573 has_input: true,
11574 errors: &[
11575 "InternalFailureException",
11576 "InvalidRequestException",
11577 "LimitExceededException",
11578 "ThrottlingException",
11579 ],
11580 rules: &[Rule {
11581 wire: "targetCheckNames",
11582 src: Src::Body,
11583 req: true,
11584 kind: K::List,
11585 min_len: None,
11586 max_len: None,
11587 min_val: None,
11588 max_val: None,
11589 enums: &[],
11590 }],
11591 omembers: &[("taskId", K::Str)],
11592 list_field: None,
11593 list_elems: &[],
11594 list_scalar: false,
11595 req_payload: false,
11596 },
11597 OpMeta {
11598 op: "StartThingRegistrationTask",
11599 method: "POST",
11600 segs: &[Seg::Fixed("thing-registration-tasks")],
11601 verb: Verb::Action,
11602 rtype: "thing-registration-tasks",
11603 nlabels: 0,
11604 has_input: true,
11605 errors: &[
11606 "InternalFailureException",
11607 "InvalidRequestException",
11608 "ThrottlingException",
11609 "UnauthorizedException",
11610 ],
11611 rules: &[
11612 Rule {
11613 wire: "templateBody",
11614 src: Src::Body,
11615 req: true,
11616 kind: K::Str,
11617 min_len: Some(0),
11618 max_len: Some(10240),
11619 min_val: None,
11620 max_val: None,
11621 enums: &[],
11622 },
11623 Rule {
11624 wire: "inputFileBucket",
11625 src: Src::Body,
11626 req: true,
11627 kind: K::Str,
11628 min_len: Some(3),
11629 max_len: Some(256),
11630 min_val: None,
11631 max_val: None,
11632 enums: &[],
11633 },
11634 Rule {
11635 wire: "inputFileKey",
11636 src: Src::Body,
11637 req: true,
11638 kind: K::Str,
11639 min_len: Some(1),
11640 max_len: Some(1024),
11641 min_val: None,
11642 max_val: None,
11643 enums: &[],
11644 },
11645 Rule {
11646 wire: "roleArn",
11647 src: Src::Body,
11648 req: true,
11649 kind: K::Str,
11650 min_len: Some(20),
11651 max_len: Some(2048),
11652 min_val: None,
11653 max_val: None,
11654 enums: &[],
11655 },
11656 ],
11657 omembers: &[("taskId", K::Str)],
11658 list_field: None,
11659 list_elems: &[],
11660 list_scalar: false,
11661 req_payload: false,
11662 },
11663 OpMeta {
11664 op: "StopThingRegistrationTask",
11665 method: "PUT",
11666 segs: &[
11667 Seg::Fixed("thing-registration-tasks"),
11668 Seg::Label("taskId"),
11669 Seg::Fixed("cancel"),
11670 ],
11671 verb: Verb::Action,
11672 rtype: "thing-registration-tasks",
11673 nlabels: 1,
11674 has_input: true,
11675 errors: &[
11676 "InternalFailureException",
11677 "InvalidRequestException",
11678 "ResourceNotFoundException",
11679 "ThrottlingException",
11680 "UnauthorizedException",
11681 ],
11682 rules: &[Rule {
11683 wire: "taskId",
11684 src: Src::Label,
11685 req: true,
11686 kind: K::Str,
11687 min_len: Some(0),
11688 max_len: Some(40),
11689 min_val: None,
11690 max_val: None,
11691 enums: &[],
11692 }],
11693 omembers: &[],
11694 list_field: None,
11695 list_elems: &[],
11696 list_scalar: false,
11697 req_payload: false,
11698 },
11699 OpMeta {
11700 op: "TagResource",
11701 method: "POST",
11702 segs: &[Seg::Fixed("tags")],
11703 verb: Verb::Action,
11704 rtype: "tags",
11705 nlabels: 0,
11706 has_input: true,
11707 errors: &[
11708 "InternalFailureException",
11709 "InvalidRequestException",
11710 "LimitExceededException",
11711 "ResourceNotFoundException",
11712 "ThrottlingException",
11713 ],
11714 rules: &[
11715 Rule {
11716 wire: "resourceArn",
11717 src: Src::Body,
11718 req: true,
11719 kind: K::Str,
11720 min_len: None,
11721 max_len: None,
11722 min_val: None,
11723 max_val: None,
11724 enums: &[],
11725 },
11726 Rule {
11727 wire: "tags",
11728 src: Src::Body,
11729 req: true,
11730 kind: K::List,
11731 min_len: None,
11732 max_len: None,
11733 min_val: None,
11734 max_val: None,
11735 enums: &[],
11736 },
11737 ],
11738 omembers: &[],
11739 list_field: None,
11740 list_elems: &[],
11741 list_scalar: false,
11742 req_payload: false,
11743 },
11744 OpMeta {
11745 op: "TestAuthorization",
11746 method: "POST",
11747 segs: &[Seg::Fixed("test-authorization")],
11748 verb: Verb::Action,
11749 rtype: "test-authorization",
11750 nlabels: 0,
11751 has_input: true,
11752 errors: &[
11753 "InternalFailureException",
11754 "InvalidRequestException",
11755 "LimitExceededException",
11756 "ResourceNotFoundException",
11757 "ServiceUnavailableException",
11758 "ThrottlingException",
11759 "UnauthorizedException",
11760 ],
11761 rules: &[Rule {
11762 wire: "authInfos",
11763 src: Src::Body,
11764 req: true,
11765 kind: K::List,
11766 min_len: Some(1),
11767 max_len: Some(10),
11768 min_val: None,
11769 max_val: None,
11770 enums: &[],
11771 }],
11772 omembers: &[("authResults", K::List)],
11773 list_field: Some("authResults"),
11774 list_elems: &[
11775 ("authInfo", K::Struct),
11776 ("allowed", K::Struct),
11777 ("denied", K::Struct),
11778 ("authDecision", K::Str),
11779 ("missingContextValues", K::List),
11780 ],
11781 list_scalar: false,
11782 req_payload: false,
11783 },
11784 OpMeta {
11785 op: "TestInvokeAuthorizer",
11786 method: "POST",
11787 segs: &[
11788 Seg::Fixed("authorizer"),
11789 Seg::Label("authorizerName"),
11790 Seg::Fixed("test"),
11791 ],
11792 verb: Verb::Action,
11793 rtype: "authorizer",
11794 nlabels: 1,
11795 has_input: true,
11796 errors: &[
11797 "InternalFailureException",
11798 "InvalidRequestException",
11799 "InvalidResponseException",
11800 "ResourceNotFoundException",
11801 "ServiceUnavailableException",
11802 "ThrottlingException",
11803 "UnauthorizedException",
11804 ],
11805 rules: &[
11806 Rule {
11807 wire: "authorizerName",
11808 src: Src::Label,
11809 req: true,
11810 kind: K::Str,
11811 min_len: Some(1),
11812 max_len: Some(128),
11813 min_val: None,
11814 max_val: None,
11815 enums: &[],
11816 },
11817 Rule {
11818 wire: "token",
11819 src: Src::Body,
11820 req: false,
11821 kind: K::Str,
11822 min_len: Some(1),
11823 max_len: Some(6144),
11824 min_val: None,
11825 max_val: None,
11826 enums: &[],
11827 },
11828 Rule {
11829 wire: "tokenSignature",
11830 src: Src::Body,
11831 req: false,
11832 kind: K::Str,
11833 min_len: Some(1),
11834 max_len: Some(2560),
11835 min_val: None,
11836 max_val: None,
11837 enums: &[],
11838 },
11839 ],
11840 omembers: &[
11841 ("isAuthenticated", K::Bool),
11842 ("principalId", K::Str),
11843 ("policyDocuments", K::List),
11844 ("refreshAfterInSeconds", K::Int),
11845 ("disconnectAfterInSeconds", K::Int),
11846 ],
11847 list_field: Some("policyDocuments"),
11848 list_elems: &[],
11849 list_scalar: true,
11850 req_payload: false,
11851 },
11852 OpMeta {
11853 op: "TransferCertificate",
11854 method: "PATCH",
11855 segs: &[
11856 Seg::Fixed("transfer-certificate"),
11857 Seg::Label("certificateId"),
11858 ],
11859 verb: Verb::Action,
11860 rtype: "transfer-certificate",
11861 nlabels: 1,
11862 has_input: true,
11863 errors: &[
11864 "CertificateStateException",
11865 "InternalFailureException",
11866 "InvalidRequestException",
11867 "ResourceNotFoundException",
11868 "ServiceUnavailableException",
11869 "ThrottlingException",
11870 "TransferConflictException",
11871 "UnauthorizedException",
11872 ],
11873 rules: &[
11874 Rule {
11875 wire: "certificateId",
11876 src: Src::Label,
11877 req: true,
11878 kind: K::Str,
11879 min_len: Some(64),
11880 max_len: Some(64),
11881 min_val: None,
11882 max_val: None,
11883 enums: &[],
11884 },
11885 Rule {
11886 wire: "targetAwsAccount",
11887 src: Src::Query,
11888 req: true,
11889 kind: K::Str,
11890 min_len: Some(12),
11891 max_len: Some(12),
11892 min_val: None,
11893 max_val: None,
11894 enums: &[],
11895 },
11896 Rule {
11897 wire: "transferMessage",
11898 src: Src::Body,
11899 req: false,
11900 kind: K::Str,
11901 min_len: Some(0),
11902 max_len: Some(128),
11903 min_val: None,
11904 max_val: None,
11905 enums: &[],
11906 },
11907 ],
11908 omembers: &[("transferredCertificateArn", K::Str)],
11909 list_field: None,
11910 list_elems: &[],
11911 list_scalar: false,
11912 req_payload: false,
11913 },
11914 OpMeta {
11915 op: "UntagResource",
11916 method: "POST",
11917 segs: &[Seg::Fixed("untag")],
11918 verb: Verb::Action,
11919 rtype: "untag",
11920 nlabels: 0,
11921 has_input: true,
11922 errors: &[
11923 "InternalFailureException",
11924 "InvalidRequestException",
11925 "ResourceNotFoundException",
11926 "ThrottlingException",
11927 ],
11928 rules: &[
11929 Rule {
11930 wire: "resourceArn",
11931 src: Src::Body,
11932 req: true,
11933 kind: K::Str,
11934 min_len: None,
11935 max_len: None,
11936 min_val: None,
11937 max_val: None,
11938 enums: &[],
11939 },
11940 Rule {
11941 wire: "tagKeys",
11942 src: Src::Body,
11943 req: true,
11944 kind: K::List,
11945 min_len: None,
11946 max_len: None,
11947 min_val: None,
11948 max_val: None,
11949 enums: &[],
11950 },
11951 ],
11952 omembers: &[],
11953 list_field: None,
11954 list_elems: &[],
11955 list_scalar: false,
11956 req_payload: false,
11957 },
11958 OpMeta {
11959 op: "UpdateAccountAuditConfiguration",
11960 method: "PATCH",
11961 segs: &[Seg::Fixed("audit"), Seg::Fixed("configuration")],
11962 verb: Verb::Action,
11963 rtype: "audit",
11964 nlabels: 0,
11965 has_input: true,
11966 errors: &[
11967 "InternalFailureException",
11968 "InvalidRequestException",
11969 "ThrottlingException",
11970 ],
11971 rules: &[Rule {
11972 wire: "roleArn",
11973 src: Src::Body,
11974 req: false,
11975 kind: K::Str,
11976 min_len: Some(20),
11977 max_len: Some(2048),
11978 min_val: None,
11979 max_val: None,
11980 enums: &[],
11981 }],
11982 omembers: &[],
11983 list_field: None,
11984 list_elems: &[],
11985 list_scalar: false,
11986 req_payload: false,
11987 },
11988 OpMeta {
11989 op: "UpdateAuditSuppression",
11990 method: "PATCH",
11991 segs: &[
11992 Seg::Fixed("audit"),
11993 Seg::Fixed("suppressions"),
11994 Seg::Fixed("update"),
11995 ],
11996 verb: Verb::Action,
11997 rtype: "audit",
11998 nlabels: 0,
11999 has_input: true,
12000 errors: &[
12001 "InternalFailureException",
12002 "InvalidRequestException",
12003 "ResourceNotFoundException",
12004 "ThrottlingException",
12005 ],
12006 rules: &[
12007 Rule {
12008 wire: "checkName",
12009 src: Src::Body,
12010 req: true,
12011 kind: K::Str,
12012 min_len: None,
12013 max_len: None,
12014 min_val: None,
12015 max_val: None,
12016 enums: &[],
12017 },
12018 Rule {
12019 wire: "resourceIdentifier",
12020 src: Src::Body,
12021 req: true,
12022 kind: K::Struct,
12023 min_len: None,
12024 max_len: None,
12025 min_val: None,
12026 max_val: None,
12027 enums: &[],
12028 },
12029 Rule {
12030 wire: "description",
12031 src: Src::Body,
12032 req: false,
12033 kind: K::Str,
12034 min_len: Some(0),
12035 max_len: Some(1000),
12036 min_val: None,
12037 max_val: None,
12038 enums: &[],
12039 },
12040 ],
12041 omembers: &[],
12042 list_field: None,
12043 list_elems: &[],
12044 list_scalar: false,
12045 req_payload: false,
12046 },
12047 OpMeta {
12048 op: "UpdateAuthorizer",
12049 method: "PUT",
12050 segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
12051 verb: Verb::Update,
12052 rtype: "authorizer",
12053 nlabels: 1,
12054 has_input: true,
12055 errors: &[
12056 "InternalFailureException",
12057 "InvalidRequestException",
12058 "LimitExceededException",
12059 "ResourceNotFoundException",
12060 "ServiceUnavailableException",
12061 "ThrottlingException",
12062 "UnauthorizedException",
12063 ],
12064 rules: &[
12065 Rule {
12066 wire: "authorizerName",
12067 src: Src::Label,
12068 req: true,
12069 kind: K::Str,
12070 min_len: Some(1),
12071 max_len: Some(128),
12072 min_val: None,
12073 max_val: None,
12074 enums: &[],
12075 },
12076 Rule {
12077 wire: "authorizerFunctionArn",
12078 src: Src::Body,
12079 req: false,
12080 kind: K::Str,
12081 min_len: Some(0),
12082 max_len: Some(2048),
12083 min_val: None,
12084 max_val: None,
12085 enums: &[],
12086 },
12087 Rule {
12088 wire: "tokenKeyName",
12089 src: Src::Body,
12090 req: false,
12091 kind: K::Str,
12092 min_len: Some(1),
12093 max_len: Some(128),
12094 min_val: None,
12095 max_val: None,
12096 enums: &[],
12097 },
12098 Rule {
12099 wire: "status",
12100 src: Src::Body,
12101 req: false,
12102 kind: K::Str,
12103 min_len: None,
12104 max_len: None,
12105 min_val: None,
12106 max_val: None,
12107 enums: &["ACTIVE", "INACTIVE"],
12108 },
12109 ],
12110 omembers: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
12111 list_field: None,
12112 list_elems: &[],
12113 list_scalar: false,
12114 req_payload: false,
12115 },
12116 OpMeta {
12117 op: "UpdateBillingGroup",
12118 method: "PATCH",
12119 segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
12120 verb: Verb::Update,
12121 rtype: "billing-groups",
12122 nlabels: 1,
12123 has_input: true,
12124 errors: &[
12125 "InternalFailureException",
12126 "InvalidRequestException",
12127 "ResourceNotFoundException",
12128 "ThrottlingException",
12129 "VersionConflictException",
12130 ],
12131 rules: &[
12132 Rule {
12133 wire: "billingGroupName",
12134 src: Src::Label,
12135 req: true,
12136 kind: K::Str,
12137 min_len: Some(1),
12138 max_len: Some(128),
12139 min_val: None,
12140 max_val: None,
12141 enums: &[],
12142 },
12143 Rule {
12144 wire: "billingGroupProperties",
12145 src: Src::Body,
12146 req: true,
12147 kind: K::Struct,
12148 min_len: None,
12149 max_len: None,
12150 min_val: None,
12151 max_val: None,
12152 enums: &[],
12153 },
12154 ],
12155 omembers: &[("version", K::Int)],
12156 list_field: None,
12157 list_elems: &[],
12158 list_scalar: false,
12159 req_payload: false,
12160 },
12161 OpMeta {
12162 op: "UpdateCACertificate",
12163 method: "PUT",
12164 segs: &[Seg::Fixed("cacertificate"), Seg::Label("certificateId")],
12165 verb: Verb::Update,
12166 rtype: "cacertificate",
12167 nlabels: 1,
12168 has_input: true,
12169 errors: &[
12170 "InternalFailureException",
12171 "InvalidRequestException",
12172 "ResourceNotFoundException",
12173 "ServiceUnavailableException",
12174 "ThrottlingException",
12175 "UnauthorizedException",
12176 ],
12177 rules: &[
12178 Rule {
12179 wire: "certificateId",
12180 src: Src::Label,
12181 req: true,
12182 kind: K::Str,
12183 min_len: Some(64),
12184 max_len: Some(64),
12185 min_val: None,
12186 max_val: None,
12187 enums: &[],
12188 },
12189 Rule {
12190 wire: "newStatus",
12191 src: Src::Query,
12192 req: false,
12193 kind: K::Str,
12194 min_len: None,
12195 max_len: None,
12196 min_val: None,
12197 max_val: None,
12198 enums: &["ACTIVE", "INACTIVE"],
12199 },
12200 Rule {
12201 wire: "newAutoRegistrationStatus",
12202 src: Src::Query,
12203 req: false,
12204 kind: K::Str,
12205 min_len: None,
12206 max_len: None,
12207 min_val: None,
12208 max_val: None,
12209 enums: &["ENABLE", "DISABLE"],
12210 },
12211 ],
12212 omembers: &[],
12213 list_field: None,
12214 list_elems: &[],
12215 list_scalar: false,
12216 req_payload: false,
12217 },
12218 OpMeta {
12219 op: "UpdateCertificate",
12220 method: "PUT",
12221 segs: &[Seg::Fixed("certificates"), Seg::Label("certificateId")],
12222 verb: Verb::Update,
12223 rtype: "certificates",
12224 nlabels: 1,
12225 has_input: true,
12226 errors: &[
12227 "CertificateStateException",
12228 "InternalFailureException",
12229 "InvalidRequestException",
12230 "ResourceNotFoundException",
12231 "ServiceUnavailableException",
12232 "ThrottlingException",
12233 "UnauthorizedException",
12234 ],
12235 rules: &[
12236 Rule {
12237 wire: "certificateId",
12238 src: Src::Label,
12239 req: true,
12240 kind: K::Str,
12241 min_len: Some(64),
12242 max_len: Some(64),
12243 min_val: None,
12244 max_val: None,
12245 enums: &[],
12246 },
12247 Rule {
12248 wire: "newStatus",
12249 src: Src::Query,
12250 req: true,
12251 kind: K::Str,
12252 min_len: None,
12253 max_len: None,
12254 min_val: None,
12255 max_val: None,
12256 enums: &[
12257 "ACTIVE",
12258 "INACTIVE",
12259 "REVOKED",
12260 "PENDING_TRANSFER",
12261 "REGISTER_INACTIVE",
12262 "PENDING_ACTIVATION",
12263 ],
12264 },
12265 ],
12266 omembers: &[],
12267 list_field: None,
12268 list_elems: &[],
12269 list_scalar: false,
12270 req_payload: false,
12271 },
12272 OpMeta {
12273 op: "UpdateCertificateProvider",
12274 method: "PUT",
12275 segs: &[
12276 Seg::Fixed("certificate-providers"),
12277 Seg::Label("certificateProviderName"),
12278 ],
12279 verb: Verb::Update,
12280 rtype: "certificate-providers",
12281 nlabels: 1,
12282 has_input: true,
12283 errors: &[
12284 "InternalFailureException",
12285 "InvalidRequestException",
12286 "ResourceNotFoundException",
12287 "ServiceUnavailableException",
12288 "ThrottlingException",
12289 "UnauthorizedException",
12290 ],
12291 rules: &[
12292 Rule {
12293 wire: "certificateProviderName",
12294 src: Src::Label,
12295 req: true,
12296 kind: K::Str,
12297 min_len: Some(1),
12298 max_len: Some(128),
12299 min_val: None,
12300 max_val: None,
12301 enums: &[],
12302 },
12303 Rule {
12304 wire: "lambdaFunctionArn",
12305 src: Src::Body,
12306 req: false,
12307 kind: K::Str,
12308 min_len: Some(0),
12309 max_len: Some(2048),
12310 min_val: None,
12311 max_val: None,
12312 enums: &[],
12313 },
12314 Rule {
12315 wire: "accountDefaultForOperations",
12316 src: Src::Body,
12317 req: false,
12318 kind: K::List,
12319 min_len: Some(1),
12320 max_len: Some(1),
12321 min_val: None,
12322 max_val: None,
12323 enums: &[],
12324 },
12325 ],
12326 omembers: &[
12327 ("certificateProviderName", K::Str),
12328 ("certificateProviderArn", K::Str),
12329 ],
12330 list_field: None,
12331 list_elems: &[],
12332 list_scalar: false,
12333 req_payload: false,
12334 },
12335 OpMeta {
12336 op: "UpdateCommand",
12337 method: "PATCH",
12338 segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
12339 verb: Verb::Update,
12340 rtype: "commands",
12341 nlabels: 1,
12342 has_input: true,
12343 errors: &[
12344 "ConflictException",
12345 "InternalServerException",
12346 "ResourceNotFoundException",
12347 "ThrottlingException",
12348 "ValidationException",
12349 ],
12350 rules: &[
12351 Rule {
12352 wire: "commandId",
12353 src: Src::Label,
12354 req: true,
12355 kind: K::Str,
12356 min_len: Some(1),
12357 max_len: Some(64),
12358 min_val: None,
12359 max_val: None,
12360 enums: &[],
12361 },
12362 Rule {
12363 wire: "displayName",
12364 src: Src::Body,
12365 req: false,
12366 kind: K::Str,
12367 min_len: Some(0),
12368 max_len: Some(64),
12369 min_val: None,
12370 max_val: None,
12371 enums: &[],
12372 },
12373 Rule {
12374 wire: "description",
12375 src: Src::Body,
12376 req: false,
12377 kind: K::Str,
12378 min_len: Some(0),
12379 max_len: Some(2028),
12380 min_val: None,
12381 max_val: None,
12382 enums: &[],
12383 },
12384 ],
12385 omembers: &[
12386 ("commandId", K::Str),
12387 ("displayName", K::Str),
12388 ("description", K::Str),
12389 ("deprecated", K::Bool),
12390 ("lastUpdatedAt", K::Ts),
12391 ],
12392 list_field: None,
12393 list_elems: &[],
12394 list_scalar: false,
12395 req_payload: false,
12396 },
12397 OpMeta {
12398 op: "UpdateCustomMetric",
12399 method: "PATCH",
12400 segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
12401 verb: Verb::Update,
12402 rtype: "custom-metric",
12403 nlabels: 1,
12404 has_input: true,
12405 errors: &[
12406 "InternalFailureException",
12407 "InvalidRequestException",
12408 "ResourceNotFoundException",
12409 "ThrottlingException",
12410 ],
12411 rules: &[
12412 Rule {
12413 wire: "metricName",
12414 src: Src::Label,
12415 req: true,
12416 kind: K::Str,
12417 min_len: Some(1),
12418 max_len: Some(128),
12419 min_val: None,
12420 max_val: None,
12421 enums: &[],
12422 },
12423 Rule {
12424 wire: "displayName",
12425 src: Src::Body,
12426 req: true,
12427 kind: K::Str,
12428 min_len: Some(0),
12429 max_len: Some(128),
12430 min_val: None,
12431 max_val: None,
12432 enums: &[],
12433 },
12434 ],
12435 omembers: &[
12436 ("metricName", K::Str),
12437 ("metricArn", K::Str),
12438 ("metricType", K::Str),
12439 ("displayName", K::Str),
12440 ("creationDate", K::Ts),
12441 ("lastModifiedDate", K::Ts),
12442 ],
12443 list_field: None,
12444 list_elems: &[],
12445 list_scalar: false,
12446 req_payload: false,
12447 },
12448 OpMeta {
12449 op: "UpdateDimension",
12450 method: "PATCH",
12451 segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
12452 verb: Verb::Update,
12453 rtype: "dimensions",
12454 nlabels: 1,
12455 has_input: true,
12456 errors: &[
12457 "InternalFailureException",
12458 "InvalidRequestException",
12459 "ResourceNotFoundException",
12460 "ThrottlingException",
12461 ],
12462 rules: &[
12463 Rule {
12464 wire: "name",
12465 src: Src::Label,
12466 req: true,
12467 kind: K::Str,
12468 min_len: Some(1),
12469 max_len: Some(128),
12470 min_val: None,
12471 max_val: None,
12472 enums: &[],
12473 },
12474 Rule {
12475 wire: "stringValues",
12476 src: Src::Body,
12477 req: true,
12478 kind: K::List,
12479 min_len: Some(1),
12480 max_len: Some(100),
12481 min_val: None,
12482 max_val: None,
12483 enums: &[],
12484 },
12485 ],
12486 omembers: &[
12487 ("name", K::Str),
12488 ("arn", K::Str),
12489 ("type", K::Str),
12490 ("stringValues", K::List),
12491 ("creationDate", K::Ts),
12492 ("lastModifiedDate", K::Ts),
12493 ],
12494 list_field: Some("stringValues"),
12495 list_elems: &[],
12496 list_scalar: true,
12497 req_payload: false,
12498 },
12499 OpMeta {
12500 op: "UpdateDomainConfiguration",
12501 method: "PUT",
12502 segs: &[
12503 Seg::Fixed("domainConfigurations"),
12504 Seg::Label("domainConfigurationName"),
12505 ],
12506 verb: Verb::Update,
12507 rtype: "domainConfigurations",
12508 nlabels: 1,
12509 has_input: true,
12510 errors: &[
12511 "CertificateValidationException",
12512 "InternalFailureException",
12513 "InvalidRequestException",
12514 "ResourceNotFoundException",
12515 "ServiceUnavailableException",
12516 "ThrottlingException",
12517 "UnauthorizedException",
12518 ],
12519 rules: &[
12520 Rule {
12521 wire: "domainConfigurationName",
12522 src: Src::Label,
12523 req: true,
12524 kind: K::Str,
12525 min_len: Some(1),
12526 max_len: Some(128),
12527 min_val: None,
12528 max_val: None,
12529 enums: &[],
12530 },
12531 Rule {
12532 wire: "domainConfigurationStatus",
12533 src: Src::Body,
12534 req: false,
12535 kind: K::Str,
12536 min_len: None,
12537 max_len: None,
12538 min_val: None,
12539 max_val: None,
12540 enums: &["ENABLED", "DISABLED"],
12541 },
12542 Rule {
12543 wire: "authenticationType",
12544 src: Src::Body,
12545 req: false,
12546 kind: K::Str,
12547 min_len: None,
12548 max_len: None,
12549 min_val: None,
12550 max_val: None,
12551 enums: &[
12552 "CUSTOM_AUTH_X509",
12553 "CUSTOM_AUTH",
12554 "AWS_X509",
12555 "AWS_SIGV4",
12556 "DEFAULT",
12557 ],
12558 },
12559 Rule {
12560 wire: "applicationProtocol",
12561 src: Src::Body,
12562 req: false,
12563 kind: K::Str,
12564 min_len: None,
12565 max_len: None,
12566 min_val: None,
12567 max_val: None,
12568 enums: &["SECURE_MQTT", "MQTT_WSS", "HTTPS", "DEFAULT"],
12569 },
12570 ],
12571 omembers: &[
12572 ("domainConfigurationName", K::Str),
12573 ("domainConfigurationArn", K::Str),
12574 ],
12575 list_field: None,
12576 list_elems: &[],
12577 list_scalar: false,
12578 req_payload: false,
12579 },
12580 OpMeta {
12581 op: "UpdateDynamicThingGroup",
12582 method: "PATCH",
12583 segs: &[
12584 Seg::Fixed("dynamic-thing-groups"),
12585 Seg::Label("thingGroupName"),
12586 ],
12587 verb: Verb::Update,
12588 rtype: "dynamic-thing-groups",
12589 nlabels: 1,
12590 has_input: true,
12591 errors: &[
12592 "InternalFailureException",
12593 "InvalidQueryException",
12594 "InvalidRequestException",
12595 "ResourceNotFoundException",
12596 "ThrottlingException",
12597 "VersionConflictException",
12598 ],
12599 rules: &[
12600 Rule {
12601 wire: "thingGroupName",
12602 src: Src::Label,
12603 req: true,
12604 kind: K::Str,
12605 min_len: Some(1),
12606 max_len: Some(128),
12607 min_val: None,
12608 max_val: None,
12609 enums: &[],
12610 },
12611 Rule {
12612 wire: "thingGroupProperties",
12613 src: Src::Body,
12614 req: true,
12615 kind: K::Struct,
12616 min_len: None,
12617 max_len: None,
12618 min_val: None,
12619 max_val: None,
12620 enums: &[],
12621 },
12622 Rule {
12623 wire: "indexName",
12624 src: Src::Body,
12625 req: false,
12626 kind: K::Str,
12627 min_len: Some(1),
12628 max_len: Some(128),
12629 min_val: None,
12630 max_val: None,
12631 enums: &[],
12632 },
12633 Rule {
12634 wire: "queryString",
12635 src: Src::Body,
12636 req: false,
12637 kind: K::Str,
12638 min_len: Some(1),
12639 max_len: None,
12640 min_val: None,
12641 max_val: None,
12642 enums: &[],
12643 },
12644 ],
12645 omembers: &[("version", K::Int)],
12646 list_field: None,
12647 list_elems: &[],
12648 list_scalar: false,
12649 req_payload: false,
12650 },
12651 OpMeta {
12652 op: "UpdateEncryptionConfiguration",
12653 method: "PATCH",
12654 segs: &[Seg::Fixed("encryption-configuration")],
12655 verb: Verb::Action,
12656 rtype: "encryption-configuration",
12657 nlabels: 0,
12658 has_input: true,
12659 errors: &[
12660 "InternalFailureException",
12661 "InvalidRequestException",
12662 "ServiceUnavailableException",
12663 "ThrottlingException",
12664 "UnauthorizedException",
12665 ],
12666 rules: &[
12667 Rule {
12668 wire: "encryptionType",
12669 src: Src::Body,
12670 req: true,
12671 kind: K::Str,
12672 min_len: None,
12673 max_len: None,
12674 min_val: None,
12675 max_val: None,
12676 enums: &["CUSTOMER_MANAGED_KMS_KEY", "AWS_OWNED_KMS_KEY"],
12677 },
12678 Rule {
12679 wire: "kmsKeyArn",
12680 src: Src::Body,
12681 req: false,
12682 kind: K::Str,
12683 min_len: Some(0),
12684 max_len: Some(2048),
12685 min_val: None,
12686 max_val: None,
12687 enums: &[],
12688 },
12689 Rule {
12690 wire: "kmsAccessRoleArn",
12691 src: Src::Body,
12692 req: false,
12693 kind: K::Str,
12694 min_len: Some(0),
12695 max_len: Some(2048),
12696 min_val: None,
12697 max_val: None,
12698 enums: &[],
12699 },
12700 ],
12701 omembers: &[],
12702 list_field: None,
12703 list_elems: &[],
12704 list_scalar: false,
12705 req_payload: false,
12706 },
12707 OpMeta {
12708 op: "UpdateEventConfigurations",
12709 method: "PATCH",
12710 segs: &[Seg::Fixed("event-configurations")],
12711 verb: Verb::Action,
12712 rtype: "event-configurations",
12713 nlabels: 0,
12714 has_input: true,
12715 errors: &[
12716 "InternalFailureException",
12717 "InvalidRequestException",
12718 "ThrottlingException",
12719 ],
12720 rules: &[],
12721 omembers: &[],
12722 list_field: None,
12723 list_elems: &[],
12724 list_scalar: false,
12725 req_payload: false,
12726 },
12727 OpMeta {
12728 op: "UpdateFleetMetric",
12729 method: "PATCH",
12730 segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
12731 verb: Verb::Update,
12732 rtype: "fleet-metric",
12733 nlabels: 1,
12734 has_input: true,
12735 errors: &[
12736 "IndexNotReadyException",
12737 "InternalFailureException",
12738 "InvalidAggregationException",
12739 "InvalidQueryException",
12740 "InvalidRequestException",
12741 "ResourceNotFoundException",
12742 "ServiceUnavailableException",
12743 "ThrottlingException",
12744 "UnauthorizedException",
12745 "VersionConflictException",
12746 ],
12747 rules: &[
12748 Rule {
12749 wire: "metricName",
12750 src: Src::Label,
12751 req: true,
12752 kind: K::Str,
12753 min_len: Some(1),
12754 max_len: Some(128),
12755 min_val: None,
12756 max_val: None,
12757 enums: &[],
12758 },
12759 Rule {
12760 wire: "queryString",
12761 src: Src::Body,
12762 req: false,
12763 kind: K::Str,
12764 min_len: Some(1),
12765 max_len: None,
12766 min_val: None,
12767 max_val: None,
12768 enums: &[],
12769 },
12770 Rule {
12771 wire: "period",
12772 src: Src::Body,
12773 req: false,
12774 kind: K::Int,
12775 min_len: None,
12776 max_len: None,
12777 min_val: Some(60),
12778 max_val: Some(86400),
12779 enums: &[],
12780 },
12781 Rule {
12782 wire: "aggregationField",
12783 src: Src::Body,
12784 req: false,
12785 kind: K::Str,
12786 min_len: Some(1),
12787 max_len: None,
12788 min_val: None,
12789 max_val: None,
12790 enums: &[],
12791 },
12792 Rule {
12793 wire: "description",
12794 src: Src::Body,
12795 req: false,
12796 kind: K::Str,
12797 min_len: Some(0),
12798 max_len: Some(1024),
12799 min_val: None,
12800 max_val: None,
12801 enums: &[],
12802 },
12803 Rule {
12804 wire: "indexName",
12805 src: Src::Body,
12806 req: true,
12807 kind: K::Str,
12808 min_len: Some(1),
12809 max_len: Some(128),
12810 min_val: None,
12811 max_val: None,
12812 enums: &[],
12813 },
12814 Rule {
12815 wire: "unit",
12816 src: Src::Body,
12817 req: false,
12818 kind: K::Str,
12819 min_len: None,
12820 max_len: None,
12821 min_val: None,
12822 max_val: None,
12823 enums: &[
12824 "Seconds",
12825 "Microseconds",
12826 "Milliseconds",
12827 "Bytes",
12828 "Kilobytes",
12829 "Megabytes",
12830 "Gigabytes",
12831 "Terabytes",
12832 "Bits",
12833 "Kilobits",
12834 "Megabits",
12835 "Gigabits",
12836 "Terabits",
12837 "Percent",
12838 "Count",
12839 "Bytes/Second",
12840 "Kilobytes/Second",
12841 "Megabytes/Second",
12842 "Gigabytes/Second",
12843 "Terabytes/Second",
12844 "Bits/Second",
12845 "Kilobits/Second",
12846 "Megabits/Second",
12847 "Gigabits/Second",
12848 "Terabits/Second",
12849 "Count/Second",
12850 "None",
12851 ],
12852 },
12853 ],
12854 omembers: &[],
12855 list_field: None,
12856 list_elems: &[],
12857 list_scalar: false,
12858 req_payload: false,
12859 },
12860 OpMeta {
12861 op: "UpdateIndexingConfiguration",
12862 method: "POST",
12863 segs: &[Seg::Fixed("indexing"), Seg::Fixed("config")],
12864 verb: Verb::Action,
12865 rtype: "indexing",
12866 nlabels: 0,
12867 has_input: true,
12868 errors: &[
12869 "InternalFailureException",
12870 "InvalidRequestException",
12871 "ServiceUnavailableException",
12872 "ThrottlingException",
12873 "UnauthorizedException",
12874 ],
12875 rules: &[],
12876 omembers: &[],
12877 list_field: None,
12878 list_elems: &[],
12879 list_scalar: false,
12880 req_payload: false,
12881 },
12882 OpMeta {
12883 op: "UpdateJob",
12884 method: "PATCH",
12885 segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
12886 verb: Verb::Update,
12887 rtype: "jobs",
12888 nlabels: 1,
12889 has_input: true,
12890 errors: &[
12891 "InvalidRequestException",
12892 "ResourceNotFoundException",
12893 "ServiceUnavailableException",
12894 "ThrottlingException",
12895 ],
12896 rules: &[
12897 Rule {
12898 wire: "jobId",
12899 src: Src::Label,
12900 req: true,
12901 kind: K::Str,
12902 min_len: Some(1),
12903 max_len: Some(64),
12904 min_val: None,
12905 max_val: None,
12906 enums: &[],
12907 },
12908 Rule {
12909 wire: "description",
12910 src: Src::Body,
12911 req: false,
12912 kind: K::Str,
12913 min_len: Some(0),
12914 max_len: Some(2028),
12915 min_val: None,
12916 max_val: None,
12917 enums: &[],
12918 },
12919 ],
12920 omembers: &[],
12921 list_field: None,
12922 list_elems: &[],
12923 list_scalar: false,
12924 req_payload: false,
12925 },
12926 OpMeta {
12927 op: "UpdateMitigationAction",
12928 method: "PATCH",
12929 segs: &[
12930 Seg::Fixed("mitigationactions"),
12931 Seg::Fixed("actions"),
12932 Seg::Label("actionName"),
12933 ],
12934 verb: Verb::Update,
12935 rtype: "mitigationactions",
12936 nlabels: 1,
12937 has_input: true,
12938 errors: &[
12939 "InternalFailureException",
12940 "InvalidRequestException",
12941 "ResourceNotFoundException",
12942 "ThrottlingException",
12943 ],
12944 rules: &[
12945 Rule {
12946 wire: "actionName",
12947 src: Src::Label,
12948 req: true,
12949 kind: K::Str,
12950 min_len: Some(0),
12951 max_len: Some(128),
12952 min_val: None,
12953 max_val: None,
12954 enums: &[],
12955 },
12956 Rule {
12957 wire: "roleArn",
12958 src: Src::Body,
12959 req: false,
12960 kind: K::Str,
12961 min_len: Some(20),
12962 max_len: Some(2048),
12963 min_val: None,
12964 max_val: None,
12965 enums: &[],
12966 },
12967 ],
12968 omembers: &[("actionArn", K::Str), ("actionId", K::Str)],
12969 list_field: None,
12970 list_elems: &[],
12971 list_scalar: false,
12972 req_payload: false,
12973 },
12974 OpMeta {
12975 op: "UpdatePackage",
12976 method: "PATCH",
12977 segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
12978 verb: Verb::Update,
12979 rtype: "packages",
12980 nlabels: 1,
12981 has_input: true,
12982 errors: &[
12983 "ConflictException",
12984 "InternalServerException",
12985 "ResourceNotFoundException",
12986 "ThrottlingException",
12987 "ValidationException",
12988 ],
12989 rules: &[
12990 Rule {
12991 wire: "packageName",
12992 src: Src::Label,
12993 req: true,
12994 kind: K::Str,
12995 min_len: Some(1),
12996 max_len: Some(128),
12997 min_val: None,
12998 max_val: None,
12999 enums: &[],
13000 },
13001 Rule {
13002 wire: "description",
13003 src: Src::Body,
13004 req: false,
13005 kind: K::Str,
13006 min_len: Some(0),
13007 max_len: Some(1024),
13008 min_val: None,
13009 max_val: None,
13010 enums: &[],
13011 },
13012 Rule {
13013 wire: "defaultVersionName",
13014 src: Src::Body,
13015 req: false,
13016 kind: K::Str,
13017 min_len: Some(1),
13018 max_len: Some(64),
13019 min_val: None,
13020 max_val: None,
13021 enums: &[],
13022 },
13023 Rule {
13024 wire: "clientToken",
13025 src: Src::Query,
13026 req: false,
13027 kind: K::Str,
13028 min_len: Some(36),
13029 max_len: Some(64),
13030 min_val: None,
13031 max_val: None,
13032 enums: &[],
13033 },
13034 ],
13035 omembers: &[],
13036 list_field: None,
13037 list_elems: &[],
13038 list_scalar: false,
13039 req_payload: false,
13040 },
13041 OpMeta {
13042 op: "UpdatePackageConfiguration",
13043 method: "PATCH",
13044 segs: &[Seg::Fixed("package-configuration")],
13045 verb: Verb::Action,
13046 rtype: "package-configuration",
13047 nlabels: 0,
13048 has_input: true,
13049 errors: &[
13050 "ConflictException",
13051 "InternalServerException",
13052 "ThrottlingException",
13053 "ValidationException",
13054 ],
13055 rules: &[Rule {
13056 wire: "clientToken",
13057 src: Src::Query,
13058 req: false,
13059 kind: K::Str,
13060 min_len: Some(36),
13061 max_len: Some(64),
13062 min_val: None,
13063 max_val: None,
13064 enums: &[],
13065 }],
13066 omembers: &[],
13067 list_field: None,
13068 list_elems: &[],
13069 list_scalar: false,
13070 req_payload: false,
13071 },
13072 OpMeta {
13073 op: "UpdatePackageVersion",
13074 method: "PATCH",
13075 segs: &[
13076 Seg::Fixed("packages"),
13077 Seg::Label("packageName"),
13078 Seg::Fixed("versions"),
13079 Seg::Label("versionName"),
13080 ],
13081 verb: Verb::Update,
13082 rtype: "packages",
13083 nlabels: 2,
13084 has_input: true,
13085 errors: &[
13086 "ConflictException",
13087 "InternalServerException",
13088 "ResourceNotFoundException",
13089 "ThrottlingException",
13090 "ValidationException",
13091 ],
13092 rules: &[
13093 Rule {
13094 wire: "packageName",
13095 src: Src::Label,
13096 req: true,
13097 kind: K::Str,
13098 min_len: Some(1),
13099 max_len: Some(128),
13100 min_val: None,
13101 max_val: None,
13102 enums: &[],
13103 },
13104 Rule {
13105 wire: "versionName",
13106 src: Src::Label,
13107 req: true,
13108 kind: K::Str,
13109 min_len: Some(1),
13110 max_len: Some(64),
13111 min_val: None,
13112 max_val: None,
13113 enums: &[],
13114 },
13115 Rule {
13116 wire: "description",
13117 src: Src::Body,
13118 req: false,
13119 kind: K::Str,
13120 min_len: Some(0),
13121 max_len: Some(1024),
13122 min_val: None,
13123 max_val: None,
13124 enums: &[],
13125 },
13126 Rule {
13127 wire: "action",
13128 src: Src::Body,
13129 req: false,
13130 kind: K::Str,
13131 min_len: None,
13132 max_len: None,
13133 min_val: None,
13134 max_val: None,
13135 enums: &["PUBLISH", "DEPRECATE"],
13136 },
13137 Rule {
13138 wire: "recipe",
13139 src: Src::Body,
13140 req: false,
13141 kind: K::Str,
13142 min_len: Some(0),
13143 max_len: Some(3072),
13144 min_val: None,
13145 max_val: None,
13146 enums: &[],
13147 },
13148 Rule {
13149 wire: "clientToken",
13150 src: Src::Query,
13151 req: false,
13152 kind: K::Str,
13153 min_len: Some(36),
13154 max_len: Some(64),
13155 min_val: None,
13156 max_val: None,
13157 enums: &[],
13158 },
13159 ],
13160 omembers: &[],
13161 list_field: None,
13162 list_elems: &[],
13163 list_scalar: false,
13164 req_payload: false,
13165 },
13166 OpMeta {
13167 op: "UpdateProvisioningTemplate",
13168 method: "PATCH",
13169 segs: &[
13170 Seg::Fixed("provisioning-templates"),
13171 Seg::Label("templateName"),
13172 ],
13173 verb: Verb::Update,
13174 rtype: "provisioning-templates",
13175 nlabels: 1,
13176 has_input: true,
13177 errors: &[
13178 "ConflictingResourceUpdateException",
13179 "InternalFailureException",
13180 "InvalidRequestException",
13181 "ResourceNotFoundException",
13182 "UnauthorizedException",
13183 ],
13184 rules: &[
13185 Rule {
13186 wire: "templateName",
13187 src: Src::Label,
13188 req: true,
13189 kind: K::Str,
13190 min_len: Some(1),
13191 max_len: Some(36),
13192 min_val: None,
13193 max_val: None,
13194 enums: &[],
13195 },
13196 Rule {
13197 wire: "description",
13198 src: Src::Body,
13199 req: false,
13200 kind: K::Str,
13201 min_len: Some(0),
13202 max_len: Some(500),
13203 min_val: None,
13204 max_val: None,
13205 enums: &[],
13206 },
13207 Rule {
13208 wire: "provisioningRoleArn",
13209 src: Src::Body,
13210 req: false,
13211 kind: K::Str,
13212 min_len: Some(20),
13213 max_len: Some(2048),
13214 min_val: None,
13215 max_val: None,
13216 enums: &[],
13217 },
13218 ],
13219 omembers: &[],
13220 list_field: None,
13221 list_elems: &[],
13222 list_scalar: false,
13223 req_payload: false,
13224 },
13225 OpMeta {
13226 op: "UpdateRoleAlias",
13227 method: "PUT",
13228 segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
13229 verb: Verb::Update,
13230 rtype: "role-aliases",
13231 nlabels: 1,
13232 has_input: true,
13233 errors: &[
13234 "InternalFailureException",
13235 "InvalidRequestException",
13236 "ResourceNotFoundException",
13237 "ServiceUnavailableException",
13238 "ThrottlingException",
13239 "UnauthorizedException",
13240 ],
13241 rules: &[
13242 Rule {
13243 wire: "roleAlias",
13244 src: Src::Label,
13245 req: true,
13246 kind: K::Str,
13247 min_len: Some(1),
13248 max_len: Some(128),
13249 min_val: None,
13250 max_val: None,
13251 enums: &[],
13252 },
13253 Rule {
13254 wire: "roleArn",
13255 src: Src::Body,
13256 req: false,
13257 kind: K::Str,
13258 min_len: Some(20),
13259 max_len: Some(2048),
13260 min_val: None,
13261 max_val: None,
13262 enums: &[],
13263 },
13264 Rule {
13265 wire: "credentialDurationSeconds",
13266 src: Src::Body,
13267 req: false,
13268 kind: K::Int,
13269 min_len: None,
13270 max_len: None,
13271 min_val: Some(900),
13272 max_val: Some(43200),
13273 enums: &[],
13274 },
13275 ],
13276 omembers: &[("roleAlias", K::Str), ("roleAliasArn", K::Str)],
13277 list_field: None,
13278 list_elems: &[],
13279 list_scalar: false,
13280 req_payload: false,
13281 },
13282 OpMeta {
13283 op: "UpdateScheduledAudit",
13284 method: "PATCH",
13285 segs: &[
13286 Seg::Fixed("audit"),
13287 Seg::Fixed("scheduledaudits"),
13288 Seg::Label("scheduledAuditName"),
13289 ],
13290 verb: Verb::Update,
13291 rtype: "audit",
13292 nlabels: 1,
13293 has_input: true,
13294 errors: &[
13295 "InternalFailureException",
13296 "InvalidRequestException",
13297 "ResourceNotFoundException",
13298 "ThrottlingException",
13299 ],
13300 rules: &[
13301 Rule {
13302 wire: "frequency",
13303 src: Src::Body,
13304 req: false,
13305 kind: K::Str,
13306 min_len: None,
13307 max_len: None,
13308 min_val: None,
13309 max_val: None,
13310 enums: &["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY"],
13311 },
13312 Rule {
13313 wire: "dayOfWeek",
13314 src: Src::Body,
13315 req: false,
13316 kind: K::Str,
13317 min_len: None,
13318 max_len: None,
13319 min_val: None,
13320 max_val: None,
13321 enums: &["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"],
13322 },
13323 Rule {
13324 wire: "scheduledAuditName",
13325 src: Src::Label,
13326 req: true,
13327 kind: K::Str,
13328 min_len: Some(1),
13329 max_len: Some(128),
13330 min_val: None,
13331 max_val: None,
13332 enums: &[],
13333 },
13334 ],
13335 omembers: &[("scheduledAuditArn", K::Str)],
13336 list_field: None,
13337 list_elems: &[],
13338 list_scalar: false,
13339 req_payload: false,
13340 },
13341 OpMeta {
13342 op: "UpdateSecurityProfile",
13343 method: "PATCH",
13344 segs: &[
13345 Seg::Fixed("security-profiles"),
13346 Seg::Label("securityProfileName"),
13347 ],
13348 verb: Verb::Update,
13349 rtype: "security-profiles",
13350 nlabels: 1,
13351 has_input: true,
13352 errors: &[
13353 "InternalFailureException",
13354 "InvalidRequestException",
13355 "ResourceNotFoundException",
13356 "ThrottlingException",
13357 "VersionConflictException",
13358 ],
13359 rules: &[
13360 Rule {
13361 wire: "securityProfileName",
13362 src: Src::Label,
13363 req: true,
13364 kind: K::Str,
13365 min_len: Some(1),
13366 max_len: Some(128),
13367 min_val: None,
13368 max_val: None,
13369 enums: &[],
13370 },
13371 Rule {
13372 wire: "securityProfileDescription",
13373 src: Src::Body,
13374 req: false,
13375 kind: K::Str,
13376 min_len: Some(0),
13377 max_len: Some(1000),
13378 min_val: None,
13379 max_val: None,
13380 enums: &[],
13381 },
13382 Rule {
13383 wire: "behaviors",
13384 src: Src::Body,
13385 req: false,
13386 kind: K::List,
13387 min_len: Some(0),
13388 max_len: Some(100),
13389 min_val: None,
13390 max_val: None,
13391 enums: &[],
13392 },
13393 ],
13394 omembers: &[
13395 ("securityProfileName", K::Str),
13396 ("securityProfileArn", K::Str),
13397 ("securityProfileDescription", K::Str),
13398 ("behaviors", K::List),
13399 ("alertTargets", K::Map),
13400 ("additionalMetricsToRetain", K::List),
13401 ("additionalMetricsToRetainV2", K::List),
13402 ("version", K::Int),
13403 ("creationDate", K::Ts),
13404 ("lastModifiedDate", K::Ts),
13405 ("metricsExportConfig", K::Struct),
13406 ],
13407 list_field: Some("behaviors"),
13408 list_elems: &[
13409 ("name", K::Str),
13410 ("metric", K::Str),
13411 ("metricDimension", K::Struct),
13412 ("criteria", K::Struct),
13413 ("suppressAlerts", K::Bool),
13414 ("exportMetric", K::Bool),
13415 ],
13416 list_scalar: false,
13417 req_payload: false,
13418 },
13419 OpMeta {
13420 op: "UpdateStream",
13421 method: "PUT",
13422 segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
13423 verb: Verb::Update,
13424 rtype: "streams",
13425 nlabels: 1,
13426 has_input: true,
13427 errors: &[
13428 "InternalFailureException",
13429 "InvalidRequestException",
13430 "LimitExceededException",
13431 "ResourceNotFoundException",
13432 "ServiceUnavailableException",
13433 "ThrottlingException",
13434 "UnauthorizedException",
13435 ],
13436 rules: &[
13437 Rule {
13438 wire: "streamId",
13439 src: Src::Label,
13440 req: true,
13441 kind: K::Str,
13442 min_len: Some(1),
13443 max_len: Some(128),
13444 min_val: None,
13445 max_val: None,
13446 enums: &[],
13447 },
13448 Rule {
13449 wire: "description",
13450 src: Src::Body,
13451 req: false,
13452 kind: K::Str,
13453 min_len: Some(0),
13454 max_len: Some(2028),
13455 min_val: None,
13456 max_val: None,
13457 enums: &[],
13458 },
13459 Rule {
13460 wire: "files",
13461 src: Src::Body,
13462 req: false,
13463 kind: K::List,
13464 min_len: Some(1),
13465 max_len: Some(50),
13466 min_val: None,
13467 max_val: None,
13468 enums: &[],
13469 },
13470 Rule {
13471 wire: "roleArn",
13472 src: Src::Body,
13473 req: false,
13474 kind: K::Str,
13475 min_len: Some(20),
13476 max_len: Some(2048),
13477 min_val: None,
13478 max_val: None,
13479 enums: &[],
13480 },
13481 ],
13482 omembers: &[
13483 ("streamId", K::Str),
13484 ("streamArn", K::Str),
13485 ("description", K::Str),
13486 ("streamVersion", K::Int),
13487 ],
13488 list_field: None,
13489 list_elems: &[],
13490 list_scalar: false,
13491 req_payload: false,
13492 },
13493 OpMeta {
13494 op: "UpdateThing",
13495 method: "PATCH",
13496 segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
13497 verb: Verb::Update,
13498 rtype: "things",
13499 nlabels: 1,
13500 has_input: true,
13501 errors: &[
13502 "InternalFailureException",
13503 "InvalidRequestException",
13504 "ResourceNotFoundException",
13505 "ServiceUnavailableException",
13506 "ThrottlingException",
13507 "UnauthorizedException",
13508 "VersionConflictException",
13509 ],
13510 rules: &[
13511 Rule {
13512 wire: "thingName",
13513 src: Src::Label,
13514 req: true,
13515 kind: K::Str,
13516 min_len: Some(1),
13517 max_len: Some(128),
13518 min_val: None,
13519 max_val: None,
13520 enums: &[],
13521 },
13522 Rule {
13523 wire: "thingTypeName",
13524 src: Src::Body,
13525 req: false,
13526 kind: K::Str,
13527 min_len: Some(1),
13528 max_len: Some(128),
13529 min_val: None,
13530 max_val: None,
13531 enums: &[],
13532 },
13533 ],
13534 omembers: &[],
13535 list_field: None,
13536 list_elems: &[],
13537 list_scalar: false,
13538 req_payload: false,
13539 },
13540 OpMeta {
13541 op: "UpdateThingGroup",
13542 method: "PATCH",
13543 segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
13544 verb: Verb::Update,
13545 rtype: "thing-groups",
13546 nlabels: 1,
13547 has_input: true,
13548 errors: &[
13549 "InternalFailureException",
13550 "InvalidRequestException",
13551 "ResourceNotFoundException",
13552 "ThrottlingException",
13553 "VersionConflictException",
13554 ],
13555 rules: &[
13556 Rule {
13557 wire: "thingGroupName",
13558 src: Src::Label,
13559 req: true,
13560 kind: K::Str,
13561 min_len: Some(1),
13562 max_len: Some(128),
13563 min_val: None,
13564 max_val: None,
13565 enums: &[],
13566 },
13567 Rule {
13568 wire: "thingGroupProperties",
13569 src: Src::Body,
13570 req: true,
13571 kind: K::Struct,
13572 min_len: None,
13573 max_len: None,
13574 min_val: None,
13575 max_val: None,
13576 enums: &[],
13577 },
13578 ],
13579 omembers: &[("version", K::Int)],
13580 list_field: None,
13581 list_elems: &[],
13582 list_scalar: false,
13583 req_payload: false,
13584 },
13585 OpMeta {
13586 op: "UpdateThingGroupsForThing",
13587 method: "PUT",
13588 segs: &[
13589 Seg::Fixed("thing-groups"),
13590 Seg::Fixed("updateThingGroupsForThing"),
13591 ],
13592 verb: Verb::Action,
13593 rtype: "thing-groups",
13594 nlabels: 0,
13595 has_input: true,
13596 errors: &[
13597 "InternalFailureException",
13598 "InvalidRequestException",
13599 "ResourceNotFoundException",
13600 "ThrottlingException",
13601 ],
13602 rules: &[Rule {
13603 wire: "thingName",
13604 src: Src::Body,
13605 req: false,
13606 kind: K::Str,
13607 min_len: Some(1),
13608 max_len: Some(128),
13609 min_val: None,
13610 max_val: None,
13611 enums: &[],
13612 }],
13613 omembers: &[],
13614 list_field: None,
13615 list_elems: &[],
13616 list_scalar: false,
13617 req_payload: false,
13618 },
13619 OpMeta {
13620 op: "UpdateThingType",
13621 method: "PATCH",
13622 segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
13623 verb: Verb::Update,
13624 rtype: "thing-types",
13625 nlabels: 1,
13626 has_input: true,
13627 errors: &[
13628 "InternalFailureException",
13629 "InvalidRequestException",
13630 "ResourceNotFoundException",
13631 "ServiceUnavailableException",
13632 "ThrottlingException",
13633 "UnauthorizedException",
13634 ],
13635 rules: &[Rule {
13636 wire: "thingTypeName",
13637 src: Src::Label,
13638 req: true,
13639 kind: K::Str,
13640 min_len: Some(1),
13641 max_len: Some(128),
13642 min_val: None,
13643 max_val: None,
13644 enums: &[],
13645 }],
13646 omembers: &[],
13647 list_field: None,
13648 list_elems: &[],
13649 list_scalar: false,
13650 req_payload: false,
13651 },
13652 OpMeta {
13653 op: "UpdateTopicRuleDestination",
13654 method: "PATCH",
13655 segs: &[Seg::Fixed("destinations")],
13656 verb: Verb::Action,
13657 rtype: "destinations",
13658 nlabels: 0,
13659 has_input: true,
13660 errors: &[
13661 "ConflictingResourceUpdateException",
13662 "InternalException",
13663 "InvalidRequestException",
13664 "ServiceUnavailableException",
13665 "UnauthorizedException",
13666 ],
13667 rules: &[
13668 Rule {
13669 wire: "arn",
13670 src: Src::Body,
13671 req: true,
13672 kind: K::Str,
13673 min_len: None,
13674 max_len: None,
13675 min_val: None,
13676 max_val: None,
13677 enums: &[],
13678 },
13679 Rule {
13680 wire: "status",
13681 src: Src::Body,
13682 req: true,
13683 kind: K::Str,
13684 min_len: None,
13685 max_len: None,
13686 min_val: None,
13687 max_val: None,
13688 enums: &["ENABLED", "IN_PROGRESS", "DISABLED", "ERROR", "DELETING"],
13689 },
13690 ],
13691 omembers: &[],
13692 list_field: None,
13693 list_elems: &[],
13694 list_scalar: false,
13695 req_payload: false,
13696 },
13697 OpMeta {
13698 op: "ValidateSecurityProfileBehaviors",
13699 method: "POST",
13700 segs: &[
13701 Seg::Fixed("security-profile-behaviors"),
13702 Seg::Fixed("validate"),
13703 ],
13704 verb: Verb::Action,
13705 rtype: "security-profile-behaviors",
13706 nlabels: 0,
13707 has_input: true,
13708 errors: &[
13709 "InternalFailureException",
13710 "InvalidRequestException",
13711 "ThrottlingException",
13712 ],
13713 rules: &[Rule {
13714 wire: "behaviors",
13715 src: Src::Body,
13716 req: true,
13717 kind: K::List,
13718 min_len: Some(0),
13719 max_len: Some(100),
13720 min_val: None,
13721 max_val: None,
13722 enums: &[],
13723 }],
13724 omembers: &[("valid", K::Bool), ("validationErrors", K::List)],
13725 list_field: Some("validationErrors"),
13726 list_elems: &[("errorMessage", K::Str)],
13727 list_scalar: false,
13728 req_payload: false,
13729 },
13730];
13731
13732pub static ACTIONS: &[&str] = &[
13733 "AcceptCertificateTransfer",
13734 "AddThingToBillingGroup",
13735 "AddThingToThingGroup",
13736 "AssociateSbomWithPackageVersion",
13737 "AssociateTargetsWithJob",
13738 "AttachPolicy",
13739 "AttachPrincipalPolicy",
13740 "AttachSecurityProfile",
13741 "AttachThingPrincipal",
13742 "CancelAuditMitigationActionsTask",
13743 "CancelAuditTask",
13744 "CancelCertificateTransfer",
13745 "CancelDetectMitigationActionsTask",
13746 "CancelJob",
13747 "CancelJobExecution",
13748 "ClearDefaultAuthorizer",
13749 "ConfirmTopicRuleDestination",
13750 "CreateAuditSuppression",
13751 "CreateAuthorizer",
13752 "CreateBillingGroup",
13753 "CreateCertificateFromCsr",
13754 "CreateCertificateProvider",
13755 "CreateCommand",
13756 "CreateCustomMetric",
13757 "CreateDimension",
13758 "CreateDomainConfiguration",
13759 "CreateDynamicThingGroup",
13760 "CreateFleetMetric",
13761 "CreateJob",
13762 "CreateJobTemplate",
13763 "CreateKeysAndCertificate",
13764 "CreateMitigationAction",
13765 "CreateOTAUpdate",
13766 "CreatePackage",
13767 "CreatePackageVersion",
13768 "CreatePolicy",
13769 "CreatePolicyVersion",
13770 "CreateProvisioningClaim",
13771 "CreateProvisioningTemplate",
13772 "CreateProvisioningTemplateVersion",
13773 "CreateRoleAlias",
13774 "CreateScheduledAudit",
13775 "CreateSecurityProfile",
13776 "CreateStream",
13777 "CreateThing",
13778 "CreateThingGroup",
13779 "CreateThingType",
13780 "CreateTopicRule",
13781 "CreateTopicRuleDestination",
13782 "DeleteAccountAuditConfiguration",
13783 "DeleteAuditSuppression",
13784 "DeleteAuthorizer",
13785 "DeleteBillingGroup",
13786 "DeleteCACertificate",
13787 "DeleteCertificate",
13788 "DeleteCertificateProvider",
13789 "DeleteCommand",
13790 "DeleteCommandExecution",
13791 "DeleteCustomMetric",
13792 "DeleteDimension",
13793 "DeleteDomainConfiguration",
13794 "DeleteDynamicThingGroup",
13795 "DeleteFleetMetric",
13796 "DeleteJob",
13797 "DeleteJobExecution",
13798 "DeleteJobTemplate",
13799 "DeleteMitigationAction",
13800 "DeleteOTAUpdate",
13801 "DeletePackage",
13802 "DeletePackageVersion",
13803 "DeletePolicy",
13804 "DeletePolicyVersion",
13805 "DeleteProvisioningTemplate",
13806 "DeleteProvisioningTemplateVersion",
13807 "DeleteRegistrationCode",
13808 "DeleteRoleAlias",
13809 "DeleteScheduledAudit",
13810 "DeleteSecurityProfile",
13811 "DeleteStream",
13812 "DeleteThing",
13813 "DeleteThingGroup",
13814 "DeleteThingType",
13815 "DeleteTopicRule",
13816 "DeleteTopicRuleDestination",
13817 "DeleteV2LoggingLevel",
13818 "DeprecateThingType",
13819 "DescribeAccountAuditConfiguration",
13820 "DescribeAuditFinding",
13821 "DescribeAuditMitigationActionsTask",
13822 "DescribeAuditSuppression",
13823 "DescribeAuditTask",
13824 "DescribeAuthorizer",
13825 "DescribeBillingGroup",
13826 "DescribeCACertificate",
13827 "DescribeCertificate",
13828 "DescribeCertificateProvider",
13829 "DescribeCustomMetric",
13830 "DescribeDefaultAuthorizer",
13831 "DescribeDetectMitigationActionsTask",
13832 "DescribeDimension",
13833 "DescribeDomainConfiguration",
13834 "DescribeEncryptionConfiguration",
13835 "DescribeEndpoint",
13836 "DescribeEventConfigurations",
13837 "DescribeFleetMetric",
13838 "DescribeIndex",
13839 "DescribeJob",
13840 "DescribeJobExecution",
13841 "DescribeJobTemplate",
13842 "DescribeManagedJobTemplate",
13843 "DescribeMitigationAction",
13844 "DescribeProvisioningTemplate",
13845 "DescribeProvisioningTemplateVersion",
13846 "DescribeRoleAlias",
13847 "DescribeScheduledAudit",
13848 "DescribeSecurityProfile",
13849 "DescribeStream",
13850 "DescribeThing",
13851 "DescribeThingGroup",
13852 "DescribeThingRegistrationTask",
13853 "DescribeThingType",
13854 "DetachPolicy",
13855 "DetachPrincipalPolicy",
13856 "DetachSecurityProfile",
13857 "DetachThingPrincipal",
13858 "DisableTopicRule",
13859 "DisassociateSbomFromPackageVersion",
13860 "EnableTopicRule",
13861 "GetBehaviorModelTrainingSummaries",
13862 "GetBucketsAggregation",
13863 "GetCardinality",
13864 "GetCommand",
13865 "GetCommandExecution",
13866 "GetEffectivePolicies",
13867 "GetIndexingConfiguration",
13868 "GetJobDocument",
13869 "GetLoggingOptions",
13870 "GetOTAUpdate",
13871 "GetPackage",
13872 "GetPackageConfiguration",
13873 "GetPackageVersion",
13874 "GetPercentiles",
13875 "GetPolicy",
13876 "GetPolicyVersion",
13877 "GetRegistrationCode",
13878 "GetStatistics",
13879 "GetThingConnectivityData",
13880 "GetTopicRule",
13881 "GetTopicRuleDestination",
13882 "GetV2LoggingOptions",
13883 "ListActiveViolations",
13884 "ListAttachedPolicies",
13885 "ListAuditFindings",
13886 "ListAuditMitigationActionsExecutions",
13887 "ListAuditMitigationActionsTasks",
13888 "ListAuditSuppressions",
13889 "ListAuditTasks",
13890 "ListAuthorizers",
13891 "ListBillingGroups",
13892 "ListCACertificates",
13893 "ListCertificateProviders",
13894 "ListCertificates",
13895 "ListCertificatesByCA",
13896 "ListCommandExecutions",
13897 "ListCommands",
13898 "ListCustomMetrics",
13899 "ListDetectMitigationActionsExecutions",
13900 "ListDetectMitigationActionsTasks",
13901 "ListDimensions",
13902 "ListDomainConfigurations",
13903 "ListFleetMetrics",
13904 "ListIndices",
13905 "ListJobExecutionsForJob",
13906 "ListJobExecutionsForThing",
13907 "ListJobTemplates",
13908 "ListJobs",
13909 "ListManagedJobTemplates",
13910 "ListMetricValues",
13911 "ListMitigationActions",
13912 "ListOTAUpdates",
13913 "ListOutgoingCertificates",
13914 "ListPackageVersions",
13915 "ListPackages",
13916 "ListPolicies",
13917 "ListPolicyPrincipals",
13918 "ListPolicyVersions",
13919 "ListPrincipalPolicies",
13920 "ListPrincipalThings",
13921 "ListPrincipalThingsV2",
13922 "ListProvisioningTemplateVersions",
13923 "ListProvisioningTemplates",
13924 "ListRelatedResourcesForAuditFinding",
13925 "ListRoleAliases",
13926 "ListSbomValidationResults",
13927 "ListScheduledAudits",
13928 "ListSecurityProfiles",
13929 "ListSecurityProfilesForTarget",
13930 "ListStreams",
13931 "ListTagsForResource",
13932 "ListTargetsForPolicy",
13933 "ListTargetsForSecurityProfile",
13934 "ListThingGroups",
13935 "ListThingGroupsForThing",
13936 "ListThingPrincipals",
13937 "ListThingPrincipalsV2",
13938 "ListThingRegistrationTaskReports",
13939 "ListThingRegistrationTasks",
13940 "ListThingTypes",
13941 "ListThings",
13942 "ListThingsInBillingGroup",
13943 "ListThingsInThingGroup",
13944 "ListTopicRuleDestinations",
13945 "ListTopicRules",
13946 "ListV2LoggingLevels",
13947 "ListViolationEvents",
13948 "PutVerificationStateOnViolation",
13949 "RegisterCACertificate",
13950 "RegisterCertificate",
13951 "RegisterCertificateWithoutCA",
13952 "RegisterThing",
13953 "RejectCertificateTransfer",
13954 "RemoveThingFromBillingGroup",
13955 "RemoveThingFromThingGroup",
13956 "ReplaceTopicRule",
13957 "SearchIndex",
13958 "SetDefaultAuthorizer",
13959 "SetDefaultPolicyVersion",
13960 "SetLoggingOptions",
13961 "SetV2LoggingLevel",
13962 "SetV2LoggingOptions",
13963 "StartAuditMitigationActionsTask",
13964 "StartDetectMitigationActionsTask",
13965 "StartOnDemandAuditTask",
13966 "StartThingRegistrationTask",
13967 "StopThingRegistrationTask",
13968 "TagResource",
13969 "TestAuthorization",
13970 "TestInvokeAuthorizer",
13971 "TransferCertificate",
13972 "UntagResource",
13973 "UpdateAccountAuditConfiguration",
13974 "UpdateAuditSuppression",
13975 "UpdateAuthorizer",
13976 "UpdateBillingGroup",
13977 "UpdateCACertificate",
13978 "UpdateCertificate",
13979 "UpdateCertificateProvider",
13980 "UpdateCommand",
13981 "UpdateCustomMetric",
13982 "UpdateDimension",
13983 "UpdateDomainConfiguration",
13984 "UpdateDynamicThingGroup",
13985 "UpdateEncryptionConfiguration",
13986 "UpdateEventConfigurations",
13987 "UpdateFleetMetric",
13988 "UpdateIndexingConfiguration",
13989 "UpdateJob",
13990 "UpdateMitigationAction",
13991 "UpdatePackage",
13992 "UpdatePackageConfiguration",
13993 "UpdatePackageVersion",
13994 "UpdateProvisioningTemplate",
13995 "UpdateRoleAlias",
13996 "UpdateScheduledAudit",
13997 "UpdateSecurityProfile",
13998 "UpdateStream",
13999 "UpdateThing",
14000 "UpdateThingGroup",
14001 "UpdateThingGroupsForThing",
14002 "UpdateThingType",
14003 "UpdateTopicRuleDestination",
14004 "ValidateSecurityProfileBehaviors",
14005];