1#![allow(unused_imports)]
3use crate::models::network as m;
4use crate::transport::{Core, Operation, Payload, QueryEncoding};
5use crate::{BinaryRequest, Client, EmptyRequest, PagedRequest, Request, WebSocketRequest};
6const ENDPOINT: &str = "https://network.{region}.basaltic.sh";
7static OP_0: Operation = Operation {
8 id: "attachFloatingIp",
9 method: "POST",
10 path: "/v1/floating-ips/{floating_ip_id}/interfaces",
11 authenticated: true,
12 required_query: &[],
13 required_headers: &[],
14 content_type: "application/json",
15 accept: "application/json",
16 query_encoding: &[],
17};
18static OP_1: Operation = Operation {
19 id: "attachInterfaceSecurityGroup",
20 method: "POST",
21 path: "/v1/interfaces/{interface_id}/security-groups",
22 authenticated: true,
23 required_query: &[],
24 required_headers: &[],
25 content_type: "application/json",
26 accept: "application/json",
27 query_encoding: &[],
28};
29static OP_2: Operation = Operation {
30 id: "createEgressOnlyGateway",
31 method: "POST",
32 path: "/v1/egress-only-gateways",
33 authenticated: true,
34 required_query: &[],
35 required_headers: &[],
36 content_type: "application/json",
37 accept: "application/json",
38 query_encoding: &[],
39};
40static OP_3: Operation = Operation {
41 id: "createFloatingIp",
42 method: "POST",
43 path: "/v1/floating-ips",
44 authenticated: true,
45 required_query: &[],
46 required_headers: &[],
47 content_type: "application/json",
48 accept: "application/json",
49 query_encoding: &[],
50};
51static OP_4: Operation = Operation {
52 id: "createInterface",
53 method: "POST",
54 path: "/v1/interfaces",
55 authenticated: true,
56 required_query: &[],
57 required_headers: &[],
58 content_type: "application/json",
59 accept: "application/json",
60 query_encoding: &[],
61};
62static OP_5: Operation = Operation {
63 id: "createInterfaceAddress",
64 method: "POST",
65 path: "/v1/interfaces/{interface_id}/addresses",
66 authenticated: true,
67 required_query: &[],
68 required_headers: &[],
69 content_type: "application/json",
70 accept: "application/json",
71 query_encoding: &[],
72};
73static OP_6: Operation = Operation {
74 id: "createInterfacePrefix",
75 method: "POST",
76 path: "/v1/interfaces/{interface_id}/prefixes",
77 authenticated: true,
78 required_query: &[],
79 required_headers: &[],
80 content_type: "application/json",
81 accept: "application/json",
82 query_encoding: &[],
83};
84static OP_7: Operation = Operation {
85 id: "createInternetGateway",
86 method: "POST",
87 path: "/v1/internet-gateways",
88 authenticated: true,
89 required_query: &[],
90 required_headers: &[],
91 content_type: "application/json",
92 accept: "application/json",
93 query_encoding: &[],
94};
95static OP_8: Operation = Operation {
96 id: "createNATGateway",
97 method: "POST",
98 path: "/v1/nat-gateways",
99 authenticated: true,
100 required_query: &[],
101 required_headers: &[],
102 content_type: "application/json",
103 accept: "application/json",
104 query_encoding: &[],
105};
106static OP_9: Operation = Operation {
107 id: "createPrefixPool",
108 method: "POST",
109 path: "/v1/vpcs/{vpc_id}/prefix-pools",
110 authenticated: true,
111 required_query: &[],
112 required_headers: &[],
113 content_type: "application/json",
114 accept: "application/json",
115 query_encoding: &[],
116};
117static OP_10: Operation = Operation {
118 id: "createRoute",
119 method: "POST",
120 path: "/v1/route-tables/{route_table_id}/routes",
121 authenticated: true,
122 required_query: &[],
123 required_headers: &[],
124 content_type: "application/json",
125 accept: "application/json",
126 query_encoding: &[],
127};
128static OP_11: Operation = Operation {
129 id: "createRouteTable",
130 method: "POST",
131 path: "/v1/route-tables",
132 authenticated: true,
133 required_query: &[],
134 required_headers: &[],
135 content_type: "application/json",
136 accept: "application/json",
137 query_encoding: &[],
138};
139static OP_12: Operation = Operation {
140 id: "createSecurityGroup",
141 method: "POST",
142 path: "/v1/security-groups",
143 authenticated: true,
144 required_query: &[],
145 required_headers: &[],
146 content_type: "application/json",
147 accept: "application/json",
148 query_encoding: &[],
149};
150static OP_13: Operation = Operation {
151 id: "createSecurityGroupRule",
152 method: "POST",
153 path: "/v1/security-groups/{security_group_id}/rules",
154 authenticated: true,
155 required_query: &[],
156 required_headers: &[],
157 content_type: "application/json",
158 accept: "application/json",
159 query_encoding: &[],
160};
161static OP_14: Operation = Operation {
162 id: "createSubnet",
163 method: "POST",
164 path: "/v1/subnets",
165 authenticated: true,
166 required_query: &[],
167 required_headers: &[],
168 content_type: "application/json",
169 accept: "application/json",
170 query_encoding: &[],
171};
172static OP_15: Operation = Operation {
173 id: "createVpc",
174 method: "POST",
175 path: "/v1/vpcs",
176 authenticated: true,
177 required_query: &[],
178 required_headers: &[],
179 content_type: "application/json",
180 accept: "application/json",
181 query_encoding: &[],
182};
183static OP_16: Operation = Operation {
184 id: "deleteEgressOnlyGateway",
185 method: "DELETE",
186 path: "/v1/egress-only-gateways/{egress_only_gateway_id}",
187 authenticated: true,
188 required_query: &[],
189 required_headers: &[],
190 content_type: "",
191 accept: "application/json",
192 query_encoding: &[],
193};
194static OP_17: Operation = Operation {
195 id: "deleteFloatingIp",
196 method: "DELETE",
197 path: "/v1/floating-ips/{floating_ip_id}",
198 authenticated: true,
199 required_query: &[],
200 required_headers: &[],
201 content_type: "",
202 accept: "application/json",
203 query_encoding: &[],
204};
205static OP_18: Operation = Operation {
206 id: "deleteInterface",
207 method: "DELETE",
208 path: "/v1/interfaces/{interface_id}",
209 authenticated: true,
210 required_query: &[],
211 required_headers: &[],
212 content_type: "",
213 accept: "application/json",
214 query_encoding: &[],
215};
216static OP_19: Operation = Operation {
217 id: "deleteInterfaceAddress",
218 method: "DELETE",
219 path: "/v1/interfaces/{interface_id}/addresses/{address_id}",
220 authenticated: true,
221 required_query: &[],
222 required_headers: &[],
223 content_type: "",
224 accept: "application/json",
225 query_encoding: &[],
226};
227static OP_20: Operation = Operation {
228 id: "deleteInterfacePrefix",
229 method: "DELETE",
230 path: "/v1/interfaces/{interface_id}/prefixes/{prefix_id}",
231 authenticated: true,
232 required_query: &[],
233 required_headers: &[],
234 content_type: "",
235 accept: "application/json",
236 query_encoding: &[],
237};
238static OP_21: Operation = Operation {
239 id: "deleteInternetGateway",
240 method: "DELETE",
241 path: "/v1/internet-gateways/{internet_gateway_id}",
242 authenticated: true,
243 required_query: &[],
244 required_headers: &[],
245 content_type: "",
246 accept: "application/json",
247 query_encoding: &[],
248};
249static OP_22: Operation = Operation {
250 id: "deleteNATGateway",
251 method: "DELETE",
252 path: "/v1/nat-gateways/{nat_gateway_id}",
253 authenticated: true,
254 required_query: &[],
255 required_headers: &[],
256 content_type: "",
257 accept: "application/json",
258 query_encoding: &[],
259};
260static OP_23: Operation = Operation {
261 id: "deletePrefixPool",
262 method: "DELETE",
263 path: "/v1/vpcs/{vpc_id}/prefix-pools/{pool_id}",
264 authenticated: true,
265 required_query: &[],
266 required_headers: &[],
267 content_type: "",
268 accept: "application/json",
269 query_encoding: &[],
270};
271static OP_24: Operation = Operation {
272 id: "deleteRoute",
273 method: "DELETE",
274 path: "/v1/route-tables/{route_table_id}/routes/{route_id}",
275 authenticated: true,
276 required_query: &[],
277 required_headers: &[],
278 content_type: "",
279 accept: "application/json",
280 query_encoding: &[],
281};
282static OP_25: Operation = Operation {
283 id: "deleteRouteTable",
284 method: "DELETE",
285 path: "/v1/route-tables/{route_table_id}",
286 authenticated: true,
287 required_query: &[],
288 required_headers: &[],
289 content_type: "",
290 accept: "application/json",
291 query_encoding: &[],
292};
293static OP_26: Operation = Operation {
294 id: "deleteSecurityGroup",
295 method: "DELETE",
296 path: "/v1/security-groups/{security_group_id}",
297 authenticated: true,
298 required_query: &[],
299 required_headers: &[],
300 content_type: "",
301 accept: "application/json",
302 query_encoding: &[],
303};
304static OP_27: Operation = Operation {
305 id: "deleteSecurityGroupRule",
306 method: "DELETE",
307 path: "/v1/security-groups/{security_group_id}/rules/{rule_id}",
308 authenticated: true,
309 required_query: &[],
310 required_headers: &[],
311 content_type: "",
312 accept: "application/json",
313 query_encoding: &[],
314};
315static OP_28: Operation = Operation {
316 id: "deleteSubnet",
317 method: "DELETE",
318 path: "/v1/subnets/{subnet_id}",
319 authenticated: true,
320 required_query: &[],
321 required_headers: &[],
322 content_type: "",
323 accept: "application/json",
324 query_encoding: &[],
325};
326static OP_29: Operation = Operation {
327 id: "deleteVpc",
328 method: "DELETE",
329 path: "/v1/vpcs/{vpc_id}",
330 authenticated: true,
331 required_query: &[],
332 required_headers: &[],
333 content_type: "",
334 accept: "application/json",
335 query_encoding: &[],
336};
337static OP_30: Operation = Operation {
338 id: "detachFloatingIp",
339 method: "DELETE",
340 path: "/v1/floating-ips/{floating_ip_id}/interfaces",
341 authenticated: true,
342 required_query: &[],
343 required_headers: &[],
344 content_type: "",
345 accept: "application/json",
346 query_encoding: &[],
347};
348static OP_31: Operation = Operation {
349 id: "detachFloatingIpInterface",
350 method: "DELETE",
351 path: "/v1/floating-ips/{floating_ip_id}/interfaces/{interface_id}",
352 authenticated: true,
353 required_query: &[],
354 required_headers: &[],
355 content_type: "",
356 accept: "application/json",
357 query_encoding: &[],
358};
359static OP_32: Operation = Operation {
360 id: "detachInterfaceSecurityGroup",
361 method: "DELETE",
362 path: "/v1/interfaces/{interface_id}/security-groups/{security_group_id}",
363 authenticated: true,
364 required_query: &[],
365 required_headers: &[],
366 content_type: "",
367 accept: "application/json",
368 query_encoding: &[],
369};
370static OP_33: Operation = Operation {
371 id: "enableSubnetIPv6",
372 method: "POST",
373 path: "/v1/subnets/{subnet_id}/ipv6",
374 authenticated: true,
375 required_query: &[],
376 required_headers: &[],
377 content_type: "application/json",
378 accept: "application/json",
379 query_encoding: &[],
380};
381static OP_34: Operation = Operation {
382 id: "enableVPCIPv6",
383 method: "POST",
384 path: "/v1/vpcs/{vpc_id}/ipv6",
385 authenticated: true,
386 required_query: &[],
387 required_headers: &[],
388 content_type: "application/json",
389 accept: "application/json",
390 query_encoding: &[],
391};
392static OP_35: Operation = Operation {
393 id: "getEgressOnlyGateway",
394 method: "GET",
395 path: "/v1/egress-only-gateways/{egress_only_gateway_id}",
396 authenticated: true,
397 required_query: &[],
398 required_headers: &[],
399 content_type: "",
400 accept: "application/json",
401 query_encoding: &[],
402};
403static OP_36: Operation = Operation {
404 id: "getFloatingIp",
405 method: "GET",
406 path: "/v1/floating-ips/{floating_ip_id}",
407 authenticated: true,
408 required_query: &[],
409 required_headers: &[],
410 content_type: "",
411 accept: "application/json",
412 query_encoding: &[],
413};
414static OP_37: Operation = Operation {
415 id: "getInterface",
416 method: "GET",
417 path: "/v1/interfaces/{interface_id}",
418 authenticated: true,
419 required_query: &[],
420 required_headers: &[],
421 content_type: "",
422 accept: "application/json",
423 query_encoding: &[],
424};
425static OP_38: Operation = Operation {
426 id: "getInterfaceAddress",
427 method: "GET",
428 path: "/v1/interfaces/{interface_id}/addresses/{address_id}",
429 authenticated: true,
430 required_query: &[],
431 required_headers: &[],
432 content_type: "",
433 accept: "application/json",
434 query_encoding: &[],
435};
436static OP_39: Operation = Operation {
437 id: "getInternetGateway",
438 method: "GET",
439 path: "/v1/internet-gateways/{internet_gateway_id}",
440 authenticated: true,
441 required_query: &[],
442 required_headers: &[],
443 content_type: "",
444 accept: "application/json",
445 query_encoding: &[],
446};
447static OP_40: Operation = Operation {
448 id: "getNATGateway",
449 method: "GET",
450 path: "/v1/nat-gateways/{nat_gateway_id}",
451 authenticated: true,
452 required_query: &[],
453 required_headers: &[],
454 content_type: "",
455 accept: "application/json",
456 query_encoding: &[],
457};
458static OP_41: Operation = Operation {
459 id: "getRoute",
460 method: "GET",
461 path: "/v1/route-tables/{route_table_id}/routes/{route_id}",
462 authenticated: true,
463 required_query: &[],
464 required_headers: &[],
465 content_type: "",
466 accept: "application/json",
467 query_encoding: &[],
468};
469static OP_42: Operation = Operation {
470 id: "getRouteTable",
471 method: "GET",
472 path: "/v1/route-tables/{route_table_id}",
473 authenticated: true,
474 required_query: &[],
475 required_headers: &[],
476 content_type: "",
477 accept: "application/json",
478 query_encoding: &[],
479};
480static OP_43: Operation = Operation {
481 id: "getSecurityGroup",
482 method: "GET",
483 path: "/v1/security-groups/{security_group_id}",
484 authenticated: true,
485 required_query: &[],
486 required_headers: &[],
487 content_type: "",
488 accept: "application/json",
489 query_encoding: &[],
490};
491static OP_44: Operation = Operation {
492 id: "getSecurityGroupRule",
493 method: "GET",
494 path: "/v1/security-groups/{security_group_id}/rules/{rule_id}",
495 authenticated: true,
496 required_query: &[],
497 required_headers: &[],
498 content_type: "",
499 accept: "application/json",
500 query_encoding: &[],
501};
502static OP_45: Operation = Operation {
503 id: "getSubnet",
504 method: "GET",
505 path: "/v1/subnets/{subnet_id}",
506 authenticated: true,
507 required_query: &[],
508 required_headers: &[],
509 content_type: "",
510 accept: "application/json",
511 query_encoding: &[],
512};
513static OP_46: Operation = Operation {
514 id: "getVpc",
515 method: "GET",
516 path: "/v1/vpcs/{vpc_id}",
517 authenticated: true,
518 required_query: &[],
519 required_headers: &[],
520 content_type: "",
521 accept: "application/json",
522 query_encoding: &[],
523};
524static OP_47: Operation = Operation {
525 id: "listEgressOnlyGatewayRoutes",
526 method: "GET",
527 path: "/v1/egress-only-gateways/{egress_only_gateway_id}/routes",
528 authenticated: true,
529 required_query: &[],
530 required_headers: &[],
531 content_type: "",
532 accept: "application/json",
533 query_encoding: &[
534 QueryEncoding {
535 name: "name",
536 style: "form",
537 explode: true,
538 },
539 QueryEncoding {
540 name: "crn",
541 style: "form",
542 explode: true,
543 },
544 QueryEncoding {
545 name: "limit",
546 style: "form",
547 explode: true,
548 },
549 QueryEncoding {
550 name: "marker",
551 style: "form",
552 explode: true,
553 },
554 ],
555};
556static OP_48: Operation = Operation {
557 id: "listEgressOnlyGateways",
558 method: "GET",
559 path: "/v1/egress-only-gateways",
560 authenticated: true,
561 required_query: &[],
562 required_headers: &[],
563 content_type: "",
564 accept: "application/json",
565 query_encoding: &[
566 QueryEncoding {
567 name: "name",
568 style: "form",
569 explode: true,
570 },
571 QueryEncoding {
572 name: "crn",
573 style: "form",
574 explode: true,
575 },
576 QueryEncoding {
577 name: "limit",
578 style: "form",
579 explode: true,
580 },
581 QueryEncoding {
582 name: "marker",
583 style: "form",
584 explode: true,
585 },
586 ],
587};
588static OP_49: Operation = Operation {
589 id: "listFloatingIpInterfaces",
590 method: "GET",
591 path: "/v1/floating-ips/{floating_ip_id}/interfaces",
592 authenticated: true,
593 required_query: &[],
594 required_headers: &[],
595 content_type: "",
596 accept: "application/json",
597 query_encoding: &[
598 QueryEncoding {
599 name: "limit",
600 style: "form",
601 explode: true,
602 },
603 QueryEncoding {
604 name: "marker",
605 style: "form",
606 explode: true,
607 },
608 QueryEncoding {
609 name: "crn",
610 style: "form",
611 explode: true,
612 },
613 QueryEncoding {
614 name: "name",
615 style: "form",
616 explode: true,
617 },
618 ],
619};
620static OP_50: Operation = Operation {
621 id: "listFloatingIps",
622 method: "GET",
623 path: "/v1/floating-ips",
624 authenticated: true,
625 required_query: &[],
626 required_headers: &[],
627 content_type: "",
628 accept: "application/json",
629 query_encoding: &[
630 QueryEncoding {
631 name: "name",
632 style: "form",
633 explode: true,
634 },
635 QueryEncoding {
636 name: "crn",
637 style: "form",
638 explode: true,
639 },
640 QueryEncoding {
641 name: "attached_to",
642 style: "form",
643 explode: true,
644 },
645 QueryEncoding {
646 name: "limit",
647 style: "form",
648 explode: true,
649 },
650 QueryEncoding {
651 name: "marker",
652 style: "form",
653 explode: true,
654 },
655 ],
656};
657static OP_51: Operation = Operation {
658 id: "listInterfaceAddresses",
659 method: "GET",
660 path: "/v1/interfaces/{interface_id}/addresses",
661 authenticated: true,
662 required_query: &[],
663 required_headers: &[],
664 content_type: "",
665 accept: "application/json",
666 query_encoding: &[],
667};
668static OP_52: Operation = Operation {
669 id: "listInterfacePrefixes",
670 method: "GET",
671 path: "/v1/interfaces/{interface_id}/prefixes",
672 authenticated: true,
673 required_query: &[],
674 required_headers: &[],
675 content_type: "",
676 accept: "application/json",
677 query_encoding: &[],
678};
679static OP_53: Operation = Operation {
680 id: "listInterfaceSecurityGroups",
681 method: "GET",
682 path: "/v1/interfaces/{interface_id}/security-groups",
683 authenticated: true,
684 required_query: &[],
685 required_headers: &[],
686 content_type: "",
687 accept: "application/json",
688 query_encoding: &[
689 QueryEncoding {
690 name: "name",
691 style: "form",
692 explode: true,
693 },
694 QueryEncoding {
695 name: "crn",
696 style: "form",
697 explode: true,
698 },
699 QueryEncoding {
700 name: "marker",
701 style: "form",
702 explode: true,
703 },
704 QueryEncoding {
705 name: "limit",
706 style: "form",
707 explode: true,
708 },
709 ],
710};
711static OP_54: Operation = Operation {
712 id: "listInterfaces",
713 method: "GET",
714 path: "/v1/interfaces",
715 authenticated: true,
716 required_query: &[],
717 required_headers: &[],
718 content_type: "",
719 accept: "application/json",
720 query_encoding: &[
721 QueryEncoding {
722 name: "name",
723 style: "form",
724 explode: true,
725 },
726 QueryEncoding {
727 name: "crn",
728 style: "form",
729 explode: true,
730 },
731 QueryEncoding {
732 name: "subnet",
733 style: "form",
734 explode: true,
735 },
736 QueryEncoding {
737 name: "vpc",
738 style: "form",
739 explode: true,
740 },
741 QueryEncoding {
742 name: "limit",
743 style: "form",
744 explode: true,
745 },
746 QueryEncoding {
747 name: "marker",
748 style: "form",
749 explode: true,
750 },
751 ],
752};
753static OP_55: Operation = Operation {
754 id: "listInternetGatewayRoutes",
755 method: "GET",
756 path: "/v1/internet-gateways/{internet_gateway_id}/routes",
757 authenticated: true,
758 required_query: &[],
759 required_headers: &[],
760 content_type: "",
761 accept: "application/json",
762 query_encoding: &[
763 QueryEncoding {
764 name: "name",
765 style: "form",
766 explode: true,
767 },
768 QueryEncoding {
769 name: "crn",
770 style: "form",
771 explode: true,
772 },
773 QueryEncoding {
774 name: "limit",
775 style: "form",
776 explode: true,
777 },
778 QueryEncoding {
779 name: "marker",
780 style: "form",
781 explode: true,
782 },
783 ],
784};
785static OP_56: Operation = Operation {
786 id: "listInternetGateways",
787 method: "GET",
788 path: "/v1/internet-gateways",
789 authenticated: true,
790 required_query: &[],
791 required_headers: &[],
792 content_type: "",
793 accept: "application/json",
794 query_encoding: &[
795 QueryEncoding {
796 name: "name",
797 style: "form",
798 explode: true,
799 },
800 QueryEncoding {
801 name: "crn",
802 style: "form",
803 explode: true,
804 },
805 QueryEncoding {
806 name: "limit",
807 style: "form",
808 explode: true,
809 },
810 QueryEncoding {
811 name: "marker",
812 style: "form",
813 explode: true,
814 },
815 ],
816};
817static OP_57: Operation = Operation {
818 id: "listNATGatewayRoutes",
819 method: "GET",
820 path: "/v1/nat-gateways/{nat_gateway_id}/routes",
821 authenticated: true,
822 required_query: &[],
823 required_headers: &[],
824 content_type: "",
825 accept: "application/json",
826 query_encoding: &[
827 QueryEncoding {
828 name: "name",
829 style: "form",
830 explode: true,
831 },
832 QueryEncoding {
833 name: "crn",
834 style: "form",
835 explode: true,
836 },
837 QueryEncoding {
838 name: "limit",
839 style: "form",
840 explode: true,
841 },
842 QueryEncoding {
843 name: "marker",
844 style: "form",
845 explode: true,
846 },
847 ],
848};
849static OP_58: Operation = Operation {
850 id: "listNATGateways",
851 method: "GET",
852 path: "/v1/nat-gateways",
853 authenticated: true,
854 required_query: &[],
855 required_headers: &[],
856 content_type: "",
857 accept: "application/json",
858 query_encoding: &[
859 QueryEncoding {
860 name: "name",
861 style: "form",
862 explode: true,
863 },
864 QueryEncoding {
865 name: "crn",
866 style: "form",
867 explode: true,
868 },
869 QueryEncoding {
870 name: "subnet",
871 style: "form",
872 explode: true,
873 },
874 QueryEncoding {
875 name: "vpc",
876 style: "form",
877 explode: true,
878 },
879 QueryEncoding {
880 name: "limit",
881 style: "form",
882 explode: true,
883 },
884 QueryEncoding {
885 name: "marker",
886 style: "form",
887 explode: true,
888 },
889 ],
890};
891static OP_59: Operation = Operation {
892 id: "listPrefixPools",
893 method: "GET",
894 path: "/v1/vpcs/{vpc_id}/prefix-pools",
895 authenticated: true,
896 required_query: &[],
897 required_headers: &[],
898 content_type: "",
899 accept: "application/json",
900 query_encoding: &[],
901};
902static OP_60: Operation = Operation {
903 id: "listRouteTables",
904 method: "GET",
905 path: "/v1/route-tables",
906 authenticated: true,
907 required_query: &[],
908 required_headers: &[],
909 content_type: "",
910 accept: "application/json",
911 query_encoding: &[
912 QueryEncoding {
913 name: "name",
914 style: "form",
915 explode: true,
916 },
917 QueryEncoding {
918 name: "crn",
919 style: "form",
920 explode: true,
921 },
922 QueryEncoding {
923 name: "vpc",
924 style: "form",
925 explode: true,
926 },
927 QueryEncoding {
928 name: "limit",
929 style: "form",
930 explode: true,
931 },
932 QueryEncoding {
933 name: "marker",
934 style: "form",
935 explode: true,
936 },
937 ],
938};
939static OP_61: Operation = Operation {
940 id: "listRoutes",
941 method: "GET",
942 path: "/v1/route-tables/{route_table_id}/routes",
943 authenticated: true,
944 required_query: &[],
945 required_headers: &[],
946 content_type: "",
947 accept: "application/json",
948 query_encoding: &[
949 QueryEncoding {
950 name: "name",
951 style: "form",
952 explode: true,
953 },
954 QueryEncoding {
955 name: "crn",
956 style: "form",
957 explode: true,
958 },
959 QueryEncoding {
960 name: "limit",
961 style: "form",
962 explode: true,
963 },
964 QueryEncoding {
965 name: "marker",
966 style: "form",
967 explode: true,
968 },
969 ],
970};
971static OP_62: Operation = Operation {
972 id: "listSecurityGroupRules",
973 method: "GET",
974 path: "/v1/security-groups/{security_group_id}/rules",
975 authenticated: true,
976 required_query: &[],
977 required_headers: &[],
978 content_type: "",
979 accept: "application/json",
980 query_encoding: &[
981 QueryEncoding {
982 name: "name",
983 style: "form",
984 explode: true,
985 },
986 QueryEncoding {
987 name: "crn",
988 style: "form",
989 explode: true,
990 },
991 QueryEncoding {
992 name: "limit",
993 style: "form",
994 explode: true,
995 },
996 QueryEncoding {
997 name: "marker",
998 style: "form",
999 explode: true,
1000 },
1001 ],
1002};
1003static OP_63: Operation = Operation {
1004 id: "listSecurityGroups",
1005 method: "GET",
1006 path: "/v1/security-groups",
1007 authenticated: true,
1008 required_query: &[],
1009 required_headers: &[],
1010 content_type: "",
1011 accept: "application/json",
1012 query_encoding: &[
1013 QueryEncoding {
1014 name: "name",
1015 style: "form",
1016 explode: true,
1017 },
1018 QueryEncoding {
1019 name: "crn",
1020 style: "form",
1021 explode: true,
1022 },
1023 QueryEncoding {
1024 name: "limit",
1025 style: "form",
1026 explode: true,
1027 },
1028 QueryEncoding {
1029 name: "marker",
1030 style: "form",
1031 explode: true,
1032 },
1033 ],
1034};
1035static OP_64: Operation = Operation {
1036 id: "listSubnets",
1037 method: "GET",
1038 path: "/v1/subnets",
1039 authenticated: true,
1040 required_query: &[],
1041 required_headers: &[],
1042 content_type: "",
1043 accept: "application/json",
1044 query_encoding: &[
1045 QueryEncoding {
1046 name: "name",
1047 style: "form",
1048 explode: true,
1049 },
1050 QueryEncoding {
1051 name: "crn",
1052 style: "form",
1053 explode: true,
1054 },
1055 QueryEncoding {
1056 name: "vpc",
1057 style: "form",
1058 explode: true,
1059 },
1060 QueryEncoding {
1061 name: "limit",
1062 style: "form",
1063 explode: true,
1064 },
1065 QueryEncoding {
1066 name: "marker",
1067 style: "form",
1068 explode: true,
1069 },
1070 ],
1071};
1072static OP_65: Operation = Operation {
1073 id: "listVpcs",
1074 method: "GET",
1075 path: "/v1/vpcs",
1076 authenticated: true,
1077 required_query: &[],
1078 required_headers: &[],
1079 content_type: "",
1080 accept: "application/json",
1081 query_encoding: &[
1082 QueryEncoding {
1083 name: "name",
1084 style: "form",
1085 explode: true,
1086 },
1087 QueryEncoding {
1088 name: "crn",
1089 style: "form",
1090 explode: true,
1091 },
1092 QueryEncoding {
1093 name: "limit",
1094 style: "form",
1095 explode: true,
1096 },
1097 QueryEncoding {
1098 name: "marker",
1099 style: "form",
1100 explode: true,
1101 },
1102 ],
1103};
1104static OP_66: Operation = Operation {
1105 id: "updateEgressOnlyGateway",
1106 method: "PATCH",
1107 path: "/v1/egress-only-gateways/{egress_only_gateway_id}",
1108 authenticated: true,
1109 required_query: &[],
1110 required_headers: &[],
1111 content_type: "application/json",
1112 accept: "application/json",
1113 query_encoding: &[],
1114};
1115static OP_67: Operation = Operation {
1116 id: "updateFloatingIp",
1117 method: "PATCH",
1118 path: "/v1/floating-ips/{floating_ip_id}",
1119 authenticated: true,
1120 required_query: &[],
1121 required_headers: &[],
1122 content_type: "application/json",
1123 accept: "application/json",
1124 query_encoding: &[],
1125};
1126static OP_68: Operation = Operation {
1127 id: "updateInterface",
1128 method: "PATCH",
1129 path: "/v1/interfaces/{interface_id}",
1130 authenticated: true,
1131 required_query: &[],
1132 required_headers: &[],
1133 content_type: "application/json",
1134 accept: "application/json",
1135 query_encoding: &[],
1136};
1137static OP_69: Operation = Operation {
1138 id: "updateInternetGateway",
1139 method: "PATCH",
1140 path: "/v1/internet-gateways/{internet_gateway_id}",
1141 authenticated: true,
1142 required_query: &[],
1143 required_headers: &[],
1144 content_type: "application/json",
1145 accept: "application/json",
1146 query_encoding: &[],
1147};
1148static OP_70: Operation = Operation {
1149 id: "updateNATGateway",
1150 method: "PATCH",
1151 path: "/v1/nat-gateways/{nat_gateway_id}",
1152 authenticated: true,
1153 required_query: &[],
1154 required_headers: &[],
1155 content_type: "application/json",
1156 accept: "application/json",
1157 query_encoding: &[],
1158};
1159static OP_71: Operation = Operation {
1160 id: "updateRoute",
1161 method: "PATCH",
1162 path: "/v1/route-tables/{route_table_id}/routes/{route_id}",
1163 authenticated: true,
1164 required_query: &[],
1165 required_headers: &[],
1166 content_type: "application/json",
1167 accept: "application/json",
1168 query_encoding: &[],
1169};
1170static OP_72: Operation = Operation {
1171 id: "updateRouteTable",
1172 method: "PATCH",
1173 path: "/v1/route-tables/{route_table_id}",
1174 authenticated: true,
1175 required_query: &[],
1176 required_headers: &[],
1177 content_type: "application/json",
1178 accept: "application/json",
1179 query_encoding: &[],
1180};
1181static OP_73: Operation = Operation {
1182 id: "updateSecurityGroup",
1183 method: "PATCH",
1184 path: "/v1/security-groups/{security_group_id}",
1185 authenticated: true,
1186 required_query: &[],
1187 required_headers: &[],
1188 content_type: "application/json",
1189 accept: "application/json",
1190 query_encoding: &[],
1191};
1192static OP_74: Operation = Operation {
1193 id: "updateSubnet",
1194 method: "PATCH",
1195 path: "/v1/subnets/{subnet_id}",
1196 authenticated: true,
1197 required_query: &[],
1198 required_headers: &[],
1199 content_type: "application/json",
1200 accept: "application/json",
1201 query_encoding: &[],
1202};
1203static OP_75: Operation = Operation {
1204 id: "updateVpc",
1205 method: "PATCH",
1206 path: "/v1/vpcs/{vpc_id}",
1207 authenticated: true,
1208 required_query: &[],
1209 required_headers: &[],
1210 content_type: "application/json",
1211 accept: "application/json",
1212 query_encoding: &[],
1213};
1214#[derive(Clone, Debug)]
1215pub struct NetworkService {
1216 pub(crate) client: Client,
1217}
1218impl NetworkService {
1219 pub fn attach_floating_ip(
1221 &self,
1222 floating_ip_id: &str,
1223 body: &m::AttachFloatingIpBody,
1224 ) -> Request<m::AttachFloatingIpResponse> {
1225 Request::new(Core::new(
1226 self.client.clone(),
1227 "network",
1228 ENDPOINT,
1229 &OP_0,
1230 &[("floating_ip_id", floating_ip_id)],
1231 Payload::json(body),
1232 Ok(serde_json::json!({})),
1233 ))
1234 }
1235 pub fn attach_interface_security_group(
1237 &self,
1238 interface_id: &str,
1239 body: &m::AttachInterfaceSecurityGroupBody,
1240 ) -> Request<m::AttachInterfaceSecurityGroupResponse> {
1241 Request::new(Core::new(
1242 self.client.clone(),
1243 "network",
1244 ENDPOINT,
1245 &OP_1,
1246 &[("interface_id", interface_id)],
1247 Payload::json(body),
1248 Ok(serde_json::json!({})),
1249 ))
1250 }
1251 pub fn create_egress_only_gateway(
1253 &self,
1254 body: &m::CreateEgressOnlyGatewayBody,
1255 ) -> Request<m::CreateEgressOnlyGatewayResponse> {
1256 Request::new(Core::new(
1257 self.client.clone(),
1258 "network",
1259 ENDPOINT,
1260 &OP_2,
1261 &[],
1262 Payload::json(body),
1263 Ok(serde_json::json!({})),
1264 ))
1265 }
1266 pub fn create_floating_ip(
1268 &self,
1269 body: Option<&m::CreateFloatingIpBody>,
1270 ) -> Request<m::CreateFloatingIpResponse> {
1271 Request::new(Core::new(
1272 self.client.clone(),
1273 "network",
1274 ENDPOINT,
1275 &OP_3,
1276 &[],
1277 body.map(Payload::json).unwrap_or(Ok(Payload::Empty)),
1278 Ok(serde_json::json!({})),
1279 ))
1280 }
1281 pub fn create_interface(
1283 &self,
1284 body: &m::CreateInterfaceBody,
1285 ) -> Request<m::CreateInterfaceResponse> {
1286 Request::new(Core::new(
1287 self.client.clone(),
1288 "network",
1289 ENDPOINT,
1290 &OP_4,
1291 &[],
1292 Payload::json(body),
1293 Ok(serde_json::json!({})),
1294 ))
1295 }
1296 pub fn create_interface_address(
1298 &self,
1299 interface_id: &str,
1300 body: &m::CreateInterfaceAddressBody,
1301 ) -> Request<m::CreateInterfaceAddressResponse> {
1302 Request::new(Core::new(
1303 self.client.clone(),
1304 "network",
1305 ENDPOINT,
1306 &OP_5,
1307 &[("interface_id", interface_id)],
1308 Payload::json(body),
1309 Ok(serde_json::json!({})),
1310 ))
1311 }
1312 pub fn create_interface_prefix(
1314 &self,
1315 interface_id: &str,
1316 body: &m::CreateInterfacePrefixBody,
1317 ) -> Request<m::CreateInterfacePrefixResponse> {
1318 Request::new(Core::new(
1319 self.client.clone(),
1320 "network",
1321 ENDPOINT,
1322 &OP_6,
1323 &[("interface_id", interface_id)],
1324 Payload::json(body),
1325 Ok(serde_json::json!({})),
1326 ))
1327 }
1328 pub fn create_internet_gateway(
1330 &self,
1331 body: &m::CreateInternetGatewayBody,
1332 ) -> Request<m::CreateInternetGatewayResponse> {
1333 Request::new(Core::new(
1334 self.client.clone(),
1335 "network",
1336 ENDPOINT,
1337 &OP_7,
1338 &[],
1339 Payload::json(body),
1340 Ok(serde_json::json!({})),
1341 ))
1342 }
1343 pub fn create_nat_gateway(
1345 &self,
1346 body: &m::CreateNATGatewayBody,
1347 ) -> Request<m::CreateNATGatewayResponse> {
1348 Request::new(Core::new(
1349 self.client.clone(),
1350 "network",
1351 ENDPOINT,
1352 &OP_8,
1353 &[],
1354 Payload::json(body),
1355 Ok(serde_json::json!({})),
1356 ))
1357 }
1358 pub fn create_prefix_pool(
1360 &self,
1361 vpc_id: &str,
1362 body: &m::CreatePrefixPoolBody,
1363 ) -> Request<m::CreatePrefixPoolResponse> {
1364 Request::new(Core::new(
1365 self.client.clone(),
1366 "network",
1367 ENDPOINT,
1368 &OP_9,
1369 &[("vpc_id", vpc_id)],
1370 Payload::json(body),
1371 Ok(serde_json::json!({})),
1372 ))
1373 }
1374 pub fn create_route(
1376 &self,
1377 route_table_id: &str,
1378 body: &m::CreateRouteBody,
1379 ) -> Request<m::CreateRouteResponse> {
1380 Request::new(Core::new(
1381 self.client.clone(),
1382 "network",
1383 ENDPOINT,
1384 &OP_10,
1385 &[("route_table_id", route_table_id)],
1386 Payload::json(body),
1387 Ok(serde_json::json!({})),
1388 ))
1389 }
1390 pub fn create_route_table(
1392 &self,
1393 body: &m::CreateRouteTableBody,
1394 ) -> Request<m::CreateRouteTableResponse> {
1395 Request::new(Core::new(
1396 self.client.clone(),
1397 "network",
1398 ENDPOINT,
1399 &OP_11,
1400 &[],
1401 Payload::json(body),
1402 Ok(serde_json::json!({})),
1403 ))
1404 }
1405 pub fn create_security_group(
1407 &self,
1408 body: &m::CreateSecurityGroupBody,
1409 ) -> Request<m::CreateSecurityGroupResponse> {
1410 Request::new(Core::new(
1411 self.client.clone(),
1412 "network",
1413 ENDPOINT,
1414 &OP_12,
1415 &[],
1416 Payload::json(body),
1417 Ok(serde_json::json!({})),
1418 ))
1419 }
1420 pub fn create_security_group_rule(
1422 &self,
1423 security_group_id: &str,
1424 body: &m::CreateSecurityGroupRuleBody,
1425 ) -> Request<m::CreateSecurityGroupRuleResponse> {
1426 Request::new(Core::new(
1427 self.client.clone(),
1428 "network",
1429 ENDPOINT,
1430 &OP_13,
1431 &[("security_group_id", security_group_id)],
1432 Payload::json(body),
1433 Ok(serde_json::json!({})),
1434 ))
1435 }
1436 pub fn create_subnet(&self, body: &m::CreateSubnetBody) -> Request<m::CreateSubnetResponse> {
1438 Request::new(Core::new(
1439 self.client.clone(),
1440 "network",
1441 ENDPOINT,
1442 &OP_14,
1443 &[],
1444 Payload::json(body),
1445 Ok(serde_json::json!({})),
1446 ))
1447 }
1448 pub fn create_vpc(&self, body: &m::CreateVpcBody) -> Request<m::CreateVpcResponse> {
1450 Request::new(Core::new(
1451 self.client.clone(),
1452 "network",
1453 ENDPOINT,
1454 &OP_15,
1455 &[],
1456 Payload::json(body),
1457 Ok(serde_json::json!({})),
1458 ))
1459 }
1460 pub fn delete_egress_only_gateway(&self, egress_only_gateway_id: &str) -> EmptyRequest {
1462 EmptyRequest::new(Core::new(
1463 self.client.clone(),
1464 "network",
1465 ENDPOINT,
1466 &OP_16,
1467 &[("egress_only_gateway_id", egress_only_gateway_id)],
1468 Ok(Payload::Empty),
1469 Ok(serde_json::json!({})),
1470 ))
1471 }
1472 pub fn delete_floating_ip(&self, floating_ip_id: &str) -> EmptyRequest {
1474 EmptyRequest::new(Core::new(
1475 self.client.clone(),
1476 "network",
1477 ENDPOINT,
1478 &OP_17,
1479 &[("floating_ip_id", floating_ip_id)],
1480 Ok(Payload::Empty),
1481 Ok(serde_json::json!({})),
1482 ))
1483 }
1484 pub fn delete_interface(&self, interface_id: &str) -> EmptyRequest {
1486 EmptyRequest::new(Core::new(
1487 self.client.clone(),
1488 "network",
1489 ENDPOINT,
1490 &OP_18,
1491 &[("interface_id", interface_id)],
1492 Ok(Payload::Empty),
1493 Ok(serde_json::json!({})),
1494 ))
1495 }
1496 pub fn delete_interface_address(&self, interface_id: &str, address_id: &str) -> EmptyRequest {
1498 EmptyRequest::new(Core::new(
1499 self.client.clone(),
1500 "network",
1501 ENDPOINT,
1502 &OP_19,
1503 &[("interface_id", interface_id), ("address_id", address_id)],
1504 Ok(Payload::Empty),
1505 Ok(serde_json::json!({})),
1506 ))
1507 }
1508 pub fn delete_interface_prefix(&self, interface_id: &str, prefix_id: &str) -> EmptyRequest {
1510 EmptyRequest::new(Core::new(
1511 self.client.clone(),
1512 "network",
1513 ENDPOINT,
1514 &OP_20,
1515 &[("interface_id", interface_id), ("prefix_id", prefix_id)],
1516 Ok(Payload::Empty),
1517 Ok(serde_json::json!({})),
1518 ))
1519 }
1520 pub fn delete_internet_gateway(&self, internet_gateway_id: &str) -> EmptyRequest {
1522 EmptyRequest::new(Core::new(
1523 self.client.clone(),
1524 "network",
1525 ENDPOINT,
1526 &OP_21,
1527 &[("internet_gateway_id", internet_gateway_id)],
1528 Ok(Payload::Empty),
1529 Ok(serde_json::json!({})),
1530 ))
1531 }
1532 pub fn delete_nat_gateway(&self, nat_gateway_id: &str) -> EmptyRequest {
1534 EmptyRequest::new(Core::new(
1535 self.client.clone(),
1536 "network",
1537 ENDPOINT,
1538 &OP_22,
1539 &[("nat_gateway_id", nat_gateway_id)],
1540 Ok(Payload::Empty),
1541 Ok(serde_json::json!({})),
1542 ))
1543 }
1544 pub fn delete_prefix_pool(&self, vpc_id: &str, pool_id: &str) -> EmptyRequest {
1546 EmptyRequest::new(Core::new(
1547 self.client.clone(),
1548 "network",
1549 ENDPOINT,
1550 &OP_23,
1551 &[("vpc_id", vpc_id), ("pool_id", pool_id)],
1552 Ok(Payload::Empty),
1553 Ok(serde_json::json!({})),
1554 ))
1555 }
1556 pub fn delete_route(&self, route_table_id: &str, route_id: &str) -> EmptyRequest {
1558 EmptyRequest::new(Core::new(
1559 self.client.clone(),
1560 "network",
1561 ENDPOINT,
1562 &OP_24,
1563 &[("route_table_id", route_table_id), ("route_id", route_id)],
1564 Ok(Payload::Empty),
1565 Ok(serde_json::json!({})),
1566 ))
1567 }
1568 pub fn delete_route_table(&self, route_table_id: &str) -> EmptyRequest {
1570 EmptyRequest::new(Core::new(
1571 self.client.clone(),
1572 "network",
1573 ENDPOINT,
1574 &OP_25,
1575 &[("route_table_id", route_table_id)],
1576 Ok(Payload::Empty),
1577 Ok(serde_json::json!({})),
1578 ))
1579 }
1580 pub fn delete_security_group(&self, security_group_id: &str) -> EmptyRequest {
1582 EmptyRequest::new(Core::new(
1583 self.client.clone(),
1584 "network",
1585 ENDPOINT,
1586 &OP_26,
1587 &[("security_group_id", security_group_id)],
1588 Ok(Payload::Empty),
1589 Ok(serde_json::json!({})),
1590 ))
1591 }
1592 pub fn delete_security_group_rule(
1594 &self,
1595 security_group_id: &str,
1596 rule_id: &str,
1597 ) -> EmptyRequest {
1598 EmptyRequest::new(Core::new(
1599 self.client.clone(),
1600 "network",
1601 ENDPOINT,
1602 &OP_27,
1603 &[
1604 ("security_group_id", security_group_id),
1605 ("rule_id", rule_id),
1606 ],
1607 Ok(Payload::Empty),
1608 Ok(serde_json::json!({})),
1609 ))
1610 }
1611 pub fn delete_subnet(&self, subnet_id: &str) -> EmptyRequest {
1613 EmptyRequest::new(Core::new(
1614 self.client.clone(),
1615 "network",
1616 ENDPOINT,
1617 &OP_28,
1618 &[("subnet_id", subnet_id)],
1619 Ok(Payload::Empty),
1620 Ok(serde_json::json!({})),
1621 ))
1622 }
1623 pub fn delete_vpc(&self, vpc_id: &str) -> EmptyRequest {
1625 EmptyRequest::new(Core::new(
1626 self.client.clone(),
1627 "network",
1628 ENDPOINT,
1629 &OP_29,
1630 &[("vpc_id", vpc_id)],
1631 Ok(Payload::Empty),
1632 Ok(serde_json::json!({})),
1633 ))
1634 }
1635 pub fn detach_floating_ip(&self, floating_ip_id: &str) -> EmptyRequest {
1637 EmptyRequest::new(Core::new(
1638 self.client.clone(),
1639 "network",
1640 ENDPOINT,
1641 &OP_30,
1642 &[("floating_ip_id", floating_ip_id)],
1643 Ok(Payload::Empty),
1644 Ok(serde_json::json!({})),
1645 ))
1646 }
1647 pub fn detach_floating_ip_interface(
1649 &self,
1650 floating_ip_id: &str,
1651 interface_id: &str,
1652 ) -> EmptyRequest {
1653 EmptyRequest::new(Core::new(
1654 self.client.clone(),
1655 "network",
1656 ENDPOINT,
1657 &OP_31,
1658 &[
1659 ("floating_ip_id", floating_ip_id),
1660 ("interface_id", interface_id),
1661 ],
1662 Ok(Payload::Empty),
1663 Ok(serde_json::json!({})),
1664 ))
1665 }
1666 pub fn detach_interface_security_group(
1668 &self,
1669 interface_id: &str,
1670 security_group_id: &str,
1671 ) -> EmptyRequest {
1672 EmptyRequest::new(Core::new(
1673 self.client.clone(),
1674 "network",
1675 ENDPOINT,
1676 &OP_32,
1677 &[
1678 ("interface_id", interface_id),
1679 ("security_group_id", security_group_id),
1680 ],
1681 Ok(Payload::Empty),
1682 Ok(serde_json::json!({})),
1683 ))
1684 }
1685 pub fn enable_subnet_i_pv6(
1687 &self,
1688 subnet_id: &str,
1689 body: &m::EnableSubnetIPv6Body,
1690 ) -> Request<m::EnableSubnetIPv6Response> {
1691 Request::new(Core::new(
1692 self.client.clone(),
1693 "network",
1694 ENDPOINT,
1695 &OP_33,
1696 &[("subnet_id", subnet_id)],
1697 Payload::json(body),
1698 Ok(serde_json::json!({})),
1699 ))
1700 }
1701 pub fn enable_vpci_pv6(
1703 &self,
1704 vpc_id: &str,
1705 body: &m::EnableVPCIPv6Body,
1706 ) -> Request<m::EnableVPCIPv6Response> {
1707 Request::new(Core::new(
1708 self.client.clone(),
1709 "network",
1710 ENDPOINT,
1711 &OP_34,
1712 &[("vpc_id", vpc_id)],
1713 Payload::json(body),
1714 Ok(serde_json::json!({})),
1715 ))
1716 }
1717 pub fn get_egress_only_gateway(
1719 &self,
1720 egress_only_gateway_id: &str,
1721 ) -> Request<m::GetEgressOnlyGatewayResponse> {
1722 Request::new(Core::new(
1723 self.client.clone(),
1724 "network",
1725 ENDPOINT,
1726 &OP_35,
1727 &[("egress_only_gateway_id", egress_only_gateway_id)],
1728 Ok(Payload::Empty),
1729 Ok(serde_json::json!({})),
1730 ))
1731 }
1732 pub fn get_egress_only_gateway_by_reference(
1734 &self,
1735 reference: &str,
1736 scope: &m::GetEgressOnlyGatewayScope,
1737 ) -> Request<m::GetEgressOnlyGatewayResource> {
1738 let (core, extract) = crate::request::reference_core(
1739 Core::new(
1740 self.client.clone(),
1741 "network",
1742 ENDPOINT,
1743 &OP_35,
1744 &[("egress_only_gateway_id", reference)],
1745 Ok(Payload::Empty),
1746 Ok(serde_json::json!({})),
1747 ),
1748 Core::new(
1749 self.client.clone(),
1750 "network",
1751 ENDPOINT,
1752 &OP_48,
1753 &[],
1754 Ok(Payload::Empty),
1755 serde_json::to_value(scope).map_err(crate::Error::from),
1756 ),
1757 reference,
1758 true,
1759 Some("egress_only_gateway"),
1760 "egress_only_gateways",
1761 );
1762 Request::reference(core, extract)
1763 }
1764 pub fn get_floating_ip(&self, floating_ip_id: &str) -> Request<m::GetFloatingIpResponse> {
1766 Request::new(Core::new(
1767 self.client.clone(),
1768 "network",
1769 ENDPOINT,
1770 &OP_36,
1771 &[("floating_ip_id", floating_ip_id)],
1772 Ok(Payload::Empty),
1773 Ok(serde_json::json!({})),
1774 ))
1775 }
1776 pub fn get_floating_ip_by_reference(
1778 &self,
1779 reference: &str,
1780 scope: &m::GetFloatingIpScope,
1781 ) -> Request<m::GetFloatingIpResource> {
1782 let (core, extract) = crate::request::reference_core(
1783 Core::new(
1784 self.client.clone(),
1785 "network",
1786 ENDPOINT,
1787 &OP_36,
1788 &[("floating_ip_id", reference)],
1789 Ok(Payload::Empty),
1790 Ok(serde_json::json!({})),
1791 ),
1792 Core::new(
1793 self.client.clone(),
1794 "network",
1795 ENDPOINT,
1796 &OP_50,
1797 &[],
1798 Ok(Payload::Empty),
1799 serde_json::to_value(scope).map_err(crate::Error::from),
1800 ),
1801 reference,
1802 true,
1803 Some("floating_ip"),
1804 "floating_ips",
1805 );
1806 Request::reference(core, extract)
1807 }
1808 pub fn get_interface(&self, interface_id: &str) -> Request<m::GetInterfaceResponse> {
1810 Request::new(Core::new(
1811 self.client.clone(),
1812 "network",
1813 ENDPOINT,
1814 &OP_37,
1815 &[("interface_id", interface_id)],
1816 Ok(Payload::Empty),
1817 Ok(serde_json::json!({})),
1818 ))
1819 }
1820 pub fn get_interface_by_reference(
1822 &self,
1823 reference: &str,
1824 scope: &m::GetInterfaceScope,
1825 ) -> Request<m::GetInterfaceResource> {
1826 let (core, extract) = crate::request::reference_core(
1827 Core::new(
1828 self.client.clone(),
1829 "network",
1830 ENDPOINT,
1831 &OP_37,
1832 &[("interface_id", reference)],
1833 Ok(Payload::Empty),
1834 Ok(serde_json::json!({})),
1835 ),
1836 Core::new(
1837 self.client.clone(),
1838 "network",
1839 ENDPOINT,
1840 &OP_54,
1841 &[],
1842 Ok(Payload::Empty),
1843 serde_json::to_value(scope).map_err(crate::Error::from),
1844 ),
1845 reference,
1846 true,
1847 Some("interface"),
1848 "interfaces",
1849 );
1850 Request::reference(core, extract)
1851 }
1852 pub fn get_interface_address(
1854 &self,
1855 interface_id: &str,
1856 address_id: &str,
1857 ) -> Request<m::GetInterfaceAddressResponse> {
1858 Request::new(Core::new(
1859 self.client.clone(),
1860 "network",
1861 ENDPOINT,
1862 &OP_38,
1863 &[("interface_id", interface_id), ("address_id", address_id)],
1864 Ok(Payload::Empty),
1865 Ok(serde_json::json!({})),
1866 ))
1867 }
1868 pub fn get_internet_gateway(
1870 &self,
1871 internet_gateway_id: &str,
1872 ) -> Request<m::GetInternetGatewayResponse> {
1873 Request::new(Core::new(
1874 self.client.clone(),
1875 "network",
1876 ENDPOINT,
1877 &OP_39,
1878 &[("internet_gateway_id", internet_gateway_id)],
1879 Ok(Payload::Empty),
1880 Ok(serde_json::json!({})),
1881 ))
1882 }
1883 pub fn get_internet_gateway_by_reference(
1885 &self,
1886 reference: &str,
1887 scope: &m::GetInternetGatewayScope,
1888 ) -> Request<m::GetInternetGatewayResource> {
1889 let (core, extract) = crate::request::reference_core(
1890 Core::new(
1891 self.client.clone(),
1892 "network",
1893 ENDPOINT,
1894 &OP_39,
1895 &[("internet_gateway_id", reference)],
1896 Ok(Payload::Empty),
1897 Ok(serde_json::json!({})),
1898 ),
1899 Core::new(
1900 self.client.clone(),
1901 "network",
1902 ENDPOINT,
1903 &OP_56,
1904 &[],
1905 Ok(Payload::Empty),
1906 serde_json::to_value(scope).map_err(crate::Error::from),
1907 ),
1908 reference,
1909 true,
1910 Some("internet_gateway"),
1911 "internet_gateways",
1912 );
1913 Request::reference(core, extract)
1914 }
1915 pub fn get_nat_gateway(&self, nat_gateway_id: &str) -> Request<m::GetNATGatewayResponse> {
1917 Request::new(Core::new(
1918 self.client.clone(),
1919 "network",
1920 ENDPOINT,
1921 &OP_40,
1922 &[("nat_gateway_id", nat_gateway_id)],
1923 Ok(Payload::Empty),
1924 Ok(serde_json::json!({})),
1925 ))
1926 }
1927 pub fn get_nat_gateway_by_reference(
1929 &self,
1930 reference: &str,
1931 scope: &m::GetNATGatewayScope,
1932 ) -> Request<m::GetNATGatewayResource> {
1933 let (core, extract) = crate::request::reference_core(
1934 Core::new(
1935 self.client.clone(),
1936 "network",
1937 ENDPOINT,
1938 &OP_40,
1939 &[("nat_gateway_id", reference)],
1940 Ok(Payload::Empty),
1941 Ok(serde_json::json!({})),
1942 ),
1943 Core::new(
1944 self.client.clone(),
1945 "network",
1946 ENDPOINT,
1947 &OP_58,
1948 &[],
1949 Ok(Payload::Empty),
1950 serde_json::to_value(scope).map_err(crate::Error::from),
1951 ),
1952 reference,
1953 true,
1954 Some("nat_gateway"),
1955 "nat_gateways",
1956 );
1957 Request::reference(core, extract)
1958 }
1959 pub fn get_route(&self, route_table_id: &str, route_id: &str) -> Request<m::GetRouteResponse> {
1961 Request::new(Core::new(
1962 self.client.clone(),
1963 "network",
1964 ENDPOINT,
1965 &OP_41,
1966 &[("route_table_id", route_table_id), ("route_id", route_id)],
1967 Ok(Payload::Empty),
1968 Ok(serde_json::json!({})),
1969 ))
1970 }
1971 pub fn get_route_by_reference(
1973 &self,
1974 route_table_id: &str,
1975 reference: &str,
1976 scope: &m::GetRouteScope,
1977 ) -> Request<m::GetRouteResource> {
1978 let (core, extract) = crate::request::reference_core(
1979 Core::new(
1980 self.client.clone(),
1981 "network",
1982 ENDPOINT,
1983 &OP_41,
1984 &[("route_table_id", route_table_id), ("route_id", reference)],
1985 Ok(Payload::Empty),
1986 Ok(serde_json::json!({})),
1987 ),
1988 Core::new(
1989 self.client.clone(),
1990 "network",
1991 ENDPOINT,
1992 &OP_61,
1993 &[("route_table_id", route_table_id)],
1994 Ok(Payload::Empty),
1995 serde_json::to_value(scope).map_err(crate::Error::from),
1996 ),
1997 reference,
1998 true,
1999 Some("route"),
2000 "routes",
2001 );
2002 Request::reference(core, extract)
2003 }
2004 pub fn get_route_table(&self, route_table_id: &str) -> Request<m::GetRouteTableResponse> {
2006 Request::new(Core::new(
2007 self.client.clone(),
2008 "network",
2009 ENDPOINT,
2010 &OP_42,
2011 &[("route_table_id", route_table_id)],
2012 Ok(Payload::Empty),
2013 Ok(serde_json::json!({})),
2014 ))
2015 }
2016 pub fn get_route_table_by_reference(
2018 &self,
2019 reference: &str,
2020 scope: &m::GetRouteTableScope,
2021 ) -> Request<m::GetRouteTableResource> {
2022 let (core, extract) = crate::request::reference_core(
2023 Core::new(
2024 self.client.clone(),
2025 "network",
2026 ENDPOINT,
2027 &OP_42,
2028 &[("route_table_id", reference)],
2029 Ok(Payload::Empty),
2030 Ok(serde_json::json!({})),
2031 ),
2032 Core::new(
2033 self.client.clone(),
2034 "network",
2035 ENDPOINT,
2036 &OP_60,
2037 &[],
2038 Ok(Payload::Empty),
2039 serde_json::to_value(scope).map_err(crate::Error::from),
2040 ),
2041 reference,
2042 true,
2043 Some("route_table"),
2044 "route_tables",
2045 );
2046 Request::reference(core, extract)
2047 }
2048 pub fn get_security_group(
2050 &self,
2051 security_group_id: &str,
2052 ) -> Request<m::GetSecurityGroupResponse> {
2053 Request::new(Core::new(
2054 self.client.clone(),
2055 "network",
2056 ENDPOINT,
2057 &OP_43,
2058 &[("security_group_id", security_group_id)],
2059 Ok(Payload::Empty),
2060 Ok(serde_json::json!({})),
2061 ))
2062 }
2063 pub fn get_security_group_by_reference(
2065 &self,
2066 reference: &str,
2067 scope: &m::GetSecurityGroupScope,
2068 ) -> Request<m::GetSecurityGroupResource> {
2069 let (core, extract) = crate::request::reference_core(
2070 Core::new(
2071 self.client.clone(),
2072 "network",
2073 ENDPOINT,
2074 &OP_43,
2075 &[("security_group_id", reference)],
2076 Ok(Payload::Empty),
2077 Ok(serde_json::json!({})),
2078 ),
2079 Core::new(
2080 self.client.clone(),
2081 "network",
2082 ENDPOINT,
2083 &OP_63,
2084 &[],
2085 Ok(Payload::Empty),
2086 serde_json::to_value(scope).map_err(crate::Error::from),
2087 ),
2088 reference,
2089 true,
2090 Some("security_group"),
2091 "security_groups",
2092 );
2093 Request::reference(core, extract)
2094 }
2095 pub fn get_security_group_rule(
2097 &self,
2098 security_group_id: &str,
2099 rule_id: &str,
2100 ) -> Request<m::GetSecurityGroupRuleResponse> {
2101 Request::new(Core::new(
2102 self.client.clone(),
2103 "network",
2104 ENDPOINT,
2105 &OP_44,
2106 &[
2107 ("security_group_id", security_group_id),
2108 ("rule_id", rule_id),
2109 ],
2110 Ok(Payload::Empty),
2111 Ok(serde_json::json!({})),
2112 ))
2113 }
2114 pub fn get_security_group_rule_by_reference(
2116 &self,
2117 security_group_id: &str,
2118 reference: &str,
2119 scope: &m::GetSecurityGroupRuleScope,
2120 ) -> Request<m::GetSecurityGroupRuleResource> {
2121 let (core, extract) = crate::request::reference_core(
2122 Core::new(
2123 self.client.clone(),
2124 "network",
2125 ENDPOINT,
2126 &OP_44,
2127 &[
2128 ("security_group_id", security_group_id),
2129 ("rule_id", reference),
2130 ],
2131 Ok(Payload::Empty),
2132 Ok(serde_json::json!({})),
2133 ),
2134 Core::new(
2135 self.client.clone(),
2136 "network",
2137 ENDPOINT,
2138 &OP_62,
2139 &[("security_group_id", security_group_id)],
2140 Ok(Payload::Empty),
2141 serde_json::to_value(scope).map_err(crate::Error::from),
2142 ),
2143 reference,
2144 true,
2145 Some("rule"),
2146 "rules",
2147 );
2148 Request::reference(core, extract)
2149 }
2150 pub fn get_subnet(&self, subnet_id: &str) -> Request<m::GetSubnetResponse> {
2152 Request::new(Core::new(
2153 self.client.clone(),
2154 "network",
2155 ENDPOINT,
2156 &OP_45,
2157 &[("subnet_id", subnet_id)],
2158 Ok(Payload::Empty),
2159 Ok(serde_json::json!({})),
2160 ))
2161 }
2162 pub fn get_subnet_by_reference(
2164 &self,
2165 reference: &str,
2166 scope: &m::GetSubnetScope,
2167 ) -> Request<m::GetSubnetResource> {
2168 let (core, extract) = crate::request::reference_core(
2169 Core::new(
2170 self.client.clone(),
2171 "network",
2172 ENDPOINT,
2173 &OP_45,
2174 &[("subnet_id", reference)],
2175 Ok(Payload::Empty),
2176 Ok(serde_json::json!({})),
2177 ),
2178 Core::new(
2179 self.client.clone(),
2180 "network",
2181 ENDPOINT,
2182 &OP_64,
2183 &[],
2184 Ok(Payload::Empty),
2185 serde_json::to_value(scope).map_err(crate::Error::from),
2186 ),
2187 reference,
2188 true,
2189 Some("subnet"),
2190 "subnets",
2191 );
2192 Request::reference(core, extract)
2193 }
2194 pub fn get_vpc(&self, vpc_id: &str) -> Request<m::GetVpcResponse> {
2196 Request::new(Core::new(
2197 self.client.clone(),
2198 "network",
2199 ENDPOINT,
2200 &OP_46,
2201 &[("vpc_id", vpc_id)],
2202 Ok(Payload::Empty),
2203 Ok(serde_json::json!({})),
2204 ))
2205 }
2206 pub fn get_vpc_by_reference(
2208 &self,
2209 reference: &str,
2210 scope: &m::GetVpcScope,
2211 ) -> Request<m::GetVpcResource> {
2212 let (core, extract) = crate::request::reference_core(
2213 Core::new(
2214 self.client.clone(),
2215 "network",
2216 ENDPOINT,
2217 &OP_46,
2218 &[("vpc_id", reference)],
2219 Ok(Payload::Empty),
2220 Ok(serde_json::json!({})),
2221 ),
2222 Core::new(
2223 self.client.clone(),
2224 "network",
2225 ENDPOINT,
2226 &OP_65,
2227 &[],
2228 Ok(Payload::Empty),
2229 serde_json::to_value(scope).map_err(crate::Error::from),
2230 ),
2231 reference,
2232 true,
2233 Some("vpc"),
2234 "vpcs",
2235 );
2236 Request::reference(core, extract)
2237 }
2238 pub fn list_egress_only_gateway_routes(
2240 &self,
2241 egress_only_gateway_id: &str,
2242 query: &m::ListEgressOnlyGatewayRoutesQuery,
2243 ) -> PagedRequest<m::ListEgressOnlyGatewayRoutesResponse, m::ListEgressOnlyGatewayRoutesItem>
2244 {
2245 PagedRequest::new(
2246 Core::new(
2247 self.client.clone(),
2248 "network",
2249 ENDPOINT,
2250 &OP_47,
2251 &[("egress_only_gateway_id", egress_only_gateway_id)],
2252 Ok(Payload::Empty),
2253 serde_json::to_value(query).map_err(crate::Error::from),
2254 ),
2255 "routes",
2256 )
2257 }
2258 pub fn list_egress_only_gateways(
2260 &self,
2261 query: &m::ListEgressOnlyGatewaysQuery,
2262 ) -> PagedRequest<m::ListEgressOnlyGatewaysResponse, m::ListEgressOnlyGatewaysItem> {
2263 PagedRequest::new(
2264 Core::new(
2265 self.client.clone(),
2266 "network",
2267 ENDPOINT,
2268 &OP_48,
2269 &[],
2270 Ok(Payload::Empty),
2271 serde_json::to_value(query).map_err(crate::Error::from),
2272 ),
2273 "egress_only_gateways",
2274 )
2275 }
2276 pub fn list_floating_ip_interfaces(
2278 &self,
2279 floating_ip_id: &str,
2280 query: &m::ListFloatingIpInterfacesQuery,
2281 ) -> PagedRequest<m::ListFloatingIpInterfacesResponse, m::ListFloatingIpInterfacesItem> {
2282 PagedRequest::new(
2283 Core::new(
2284 self.client.clone(),
2285 "network",
2286 ENDPOINT,
2287 &OP_49,
2288 &[("floating_ip_id", floating_ip_id)],
2289 Ok(Payload::Empty),
2290 serde_json::to_value(query).map_err(crate::Error::from),
2291 ),
2292 "interfaces",
2293 )
2294 }
2295 pub fn list_floating_ips(
2297 &self,
2298 query: &m::ListFloatingIpsQuery,
2299 ) -> PagedRequest<m::ListFloatingIpsResponse, m::ListFloatingIpsItem> {
2300 PagedRequest::new(
2301 Core::new(
2302 self.client.clone(),
2303 "network",
2304 ENDPOINT,
2305 &OP_50,
2306 &[],
2307 Ok(Payload::Empty),
2308 serde_json::to_value(query).map_err(crate::Error::from),
2309 ),
2310 "floating_ips",
2311 )
2312 }
2313 pub fn list_interface_addresses(
2315 &self,
2316 interface_id: &str,
2317 ) -> PagedRequest<m::ListInterfaceAddressesResponse, m::ListInterfaceAddressesItem> {
2318 PagedRequest::new(
2319 Core::new(
2320 self.client.clone(),
2321 "network",
2322 ENDPOINT,
2323 &OP_51,
2324 &[("interface_id", interface_id)],
2325 Ok(Payload::Empty),
2326 Ok(serde_json::json!({})),
2327 ),
2328 "addresses",
2329 )
2330 }
2331 pub fn list_interface_prefixes(
2333 &self,
2334 interface_id: &str,
2335 ) -> PagedRequest<m::ListInterfacePrefixesResponse, m::ListInterfacePrefixesItem> {
2336 PagedRequest::new(
2337 Core::new(
2338 self.client.clone(),
2339 "network",
2340 ENDPOINT,
2341 &OP_52,
2342 &[("interface_id", interface_id)],
2343 Ok(Payload::Empty),
2344 Ok(serde_json::json!({})),
2345 ),
2346 "prefixes",
2347 )
2348 }
2349 pub fn list_interface_security_groups(
2351 &self,
2352 interface_id: &str,
2353 query: &m::ListInterfaceSecurityGroupsQuery,
2354 ) -> PagedRequest<m::ListInterfaceSecurityGroupsResponse, m::ListInterfaceSecurityGroupsItem>
2355 {
2356 PagedRequest::new(
2357 Core::new(
2358 self.client.clone(),
2359 "network",
2360 ENDPOINT,
2361 &OP_53,
2362 &[("interface_id", interface_id)],
2363 Ok(Payload::Empty),
2364 serde_json::to_value(query).map_err(crate::Error::from),
2365 ),
2366 "security_groups",
2367 )
2368 }
2369 pub fn list_interfaces(
2371 &self,
2372 query: &m::ListInterfacesQuery,
2373 ) -> PagedRequest<m::ListInterfacesResponse, m::ListInterfacesItem> {
2374 PagedRequest::new(
2375 Core::new(
2376 self.client.clone(),
2377 "network",
2378 ENDPOINT,
2379 &OP_54,
2380 &[],
2381 Ok(Payload::Empty),
2382 serde_json::to_value(query).map_err(crate::Error::from),
2383 ),
2384 "interfaces",
2385 )
2386 }
2387 pub fn list_internet_gateway_routes(
2389 &self,
2390 internet_gateway_id: &str,
2391 query: &m::ListInternetGatewayRoutesQuery,
2392 ) -> PagedRequest<m::ListInternetGatewayRoutesResponse, m::ListInternetGatewayRoutesItem> {
2393 PagedRequest::new(
2394 Core::new(
2395 self.client.clone(),
2396 "network",
2397 ENDPOINT,
2398 &OP_55,
2399 &[("internet_gateway_id", internet_gateway_id)],
2400 Ok(Payload::Empty),
2401 serde_json::to_value(query).map_err(crate::Error::from),
2402 ),
2403 "routes",
2404 )
2405 }
2406 pub fn list_internet_gateways(
2408 &self,
2409 query: &m::ListInternetGatewaysQuery,
2410 ) -> PagedRequest<m::ListInternetGatewaysResponse, m::ListInternetGatewaysItem> {
2411 PagedRequest::new(
2412 Core::new(
2413 self.client.clone(),
2414 "network",
2415 ENDPOINT,
2416 &OP_56,
2417 &[],
2418 Ok(Payload::Empty),
2419 serde_json::to_value(query).map_err(crate::Error::from),
2420 ),
2421 "internet_gateways",
2422 )
2423 }
2424 pub fn list_nat_gateway_routes(
2426 &self,
2427 nat_gateway_id: &str,
2428 query: &m::ListNATGatewayRoutesQuery,
2429 ) -> PagedRequest<m::ListNATGatewayRoutesResponse, m::ListNATGatewayRoutesItem> {
2430 PagedRequest::new(
2431 Core::new(
2432 self.client.clone(),
2433 "network",
2434 ENDPOINT,
2435 &OP_57,
2436 &[("nat_gateway_id", nat_gateway_id)],
2437 Ok(Payload::Empty),
2438 serde_json::to_value(query).map_err(crate::Error::from),
2439 ),
2440 "routes",
2441 )
2442 }
2443 pub fn list_nat_gateways(
2445 &self,
2446 query: &m::ListNATGatewaysQuery,
2447 ) -> PagedRequest<m::ListNATGatewaysResponse, m::ListNATGatewaysItem> {
2448 PagedRequest::new(
2449 Core::new(
2450 self.client.clone(),
2451 "network",
2452 ENDPOINT,
2453 &OP_58,
2454 &[],
2455 Ok(Payload::Empty),
2456 serde_json::to_value(query).map_err(crate::Error::from),
2457 ),
2458 "nat_gateways",
2459 )
2460 }
2461 pub fn list_prefix_pools(
2463 &self,
2464 vpc_id: &str,
2465 ) -> PagedRequest<m::ListPrefixPoolsResponse, m::ListPrefixPoolsItem> {
2466 PagedRequest::new(
2467 Core::new(
2468 self.client.clone(),
2469 "network",
2470 ENDPOINT,
2471 &OP_59,
2472 &[("vpc_id", vpc_id)],
2473 Ok(Payload::Empty),
2474 Ok(serde_json::json!({})),
2475 ),
2476 "prefix_pools",
2477 )
2478 }
2479 pub fn list_route_tables(
2481 &self,
2482 query: &m::ListRouteTablesQuery,
2483 ) -> PagedRequest<m::ListRouteTablesResponse, m::ListRouteTablesItem> {
2484 PagedRequest::new(
2485 Core::new(
2486 self.client.clone(),
2487 "network",
2488 ENDPOINT,
2489 &OP_60,
2490 &[],
2491 Ok(Payload::Empty),
2492 serde_json::to_value(query).map_err(crate::Error::from),
2493 ),
2494 "route_tables",
2495 )
2496 }
2497 pub fn list_routes(
2499 &self,
2500 route_table_id: &str,
2501 query: &m::ListRoutesQuery,
2502 ) -> PagedRequest<m::ListRoutesResponse, m::ListRoutesItem> {
2503 PagedRequest::new(
2504 Core::new(
2505 self.client.clone(),
2506 "network",
2507 ENDPOINT,
2508 &OP_61,
2509 &[("route_table_id", route_table_id)],
2510 Ok(Payload::Empty),
2511 serde_json::to_value(query).map_err(crate::Error::from),
2512 ),
2513 "routes",
2514 )
2515 }
2516 pub fn list_security_group_rules(
2518 &self,
2519 security_group_id: &str,
2520 query: &m::ListSecurityGroupRulesQuery,
2521 ) -> PagedRequest<m::ListSecurityGroupRulesResponse, m::ListSecurityGroupRulesItem> {
2522 PagedRequest::new(
2523 Core::new(
2524 self.client.clone(),
2525 "network",
2526 ENDPOINT,
2527 &OP_62,
2528 &[("security_group_id", security_group_id)],
2529 Ok(Payload::Empty),
2530 serde_json::to_value(query).map_err(crate::Error::from),
2531 ),
2532 "rules",
2533 )
2534 }
2535 pub fn list_security_groups(
2537 &self,
2538 query: &m::ListSecurityGroupsQuery,
2539 ) -> PagedRequest<m::ListSecurityGroupsResponse, m::ListSecurityGroupsItem> {
2540 PagedRequest::new(
2541 Core::new(
2542 self.client.clone(),
2543 "network",
2544 ENDPOINT,
2545 &OP_63,
2546 &[],
2547 Ok(Payload::Empty),
2548 serde_json::to_value(query).map_err(crate::Error::from),
2549 ),
2550 "security_groups",
2551 )
2552 }
2553 pub fn list_subnets(
2555 &self,
2556 query: &m::ListSubnetsQuery,
2557 ) -> PagedRequest<m::ListSubnetsResponse, m::ListSubnetsItem> {
2558 PagedRequest::new(
2559 Core::new(
2560 self.client.clone(),
2561 "network",
2562 ENDPOINT,
2563 &OP_64,
2564 &[],
2565 Ok(Payload::Empty),
2566 serde_json::to_value(query).map_err(crate::Error::from),
2567 ),
2568 "subnets",
2569 )
2570 }
2571 pub fn list_vpcs(
2573 &self,
2574 query: &m::ListVpcsQuery,
2575 ) -> PagedRequest<m::ListVpcsResponse, m::ListVpcsItem> {
2576 PagedRequest::new(
2577 Core::new(
2578 self.client.clone(),
2579 "network",
2580 ENDPOINT,
2581 &OP_65,
2582 &[],
2583 Ok(Payload::Empty),
2584 serde_json::to_value(query).map_err(crate::Error::from),
2585 ),
2586 "vpcs",
2587 )
2588 }
2589 pub fn update_egress_only_gateway(
2591 &self,
2592 egress_only_gateway_id: &str,
2593 body: &m::UpdateEgressOnlyGatewayBody,
2594 ) -> Request<m::UpdateEgressOnlyGatewayResponse> {
2595 Request::new(Core::new(
2596 self.client.clone(),
2597 "network",
2598 ENDPOINT,
2599 &OP_66,
2600 &[("egress_only_gateway_id", egress_only_gateway_id)],
2601 Payload::json(body),
2602 Ok(serde_json::json!({})),
2603 ))
2604 }
2605 pub fn update_floating_ip(
2607 &self,
2608 floating_ip_id: &str,
2609 body: &m::UpdateFloatingIpBody,
2610 ) -> Request<m::UpdateFloatingIpResponse> {
2611 Request::new(Core::new(
2612 self.client.clone(),
2613 "network",
2614 ENDPOINT,
2615 &OP_67,
2616 &[("floating_ip_id", floating_ip_id)],
2617 Payload::json(body),
2618 Ok(serde_json::json!({})),
2619 ))
2620 }
2621 pub fn update_interface(
2623 &self,
2624 interface_id: &str,
2625 body: &m::UpdateInterfaceBody,
2626 ) -> Request<m::UpdateInterfaceResponse> {
2627 Request::new(Core::new(
2628 self.client.clone(),
2629 "network",
2630 ENDPOINT,
2631 &OP_68,
2632 &[("interface_id", interface_id)],
2633 Payload::json(body),
2634 Ok(serde_json::json!({})),
2635 ))
2636 }
2637 pub fn update_internet_gateway(
2639 &self,
2640 internet_gateway_id: &str,
2641 body: &m::UpdateInternetGatewayBody,
2642 ) -> Request<m::UpdateInternetGatewayResponse> {
2643 Request::new(Core::new(
2644 self.client.clone(),
2645 "network",
2646 ENDPOINT,
2647 &OP_69,
2648 &[("internet_gateway_id", internet_gateway_id)],
2649 Payload::json(body),
2650 Ok(serde_json::json!({})),
2651 ))
2652 }
2653 pub fn update_nat_gateway(
2655 &self,
2656 nat_gateway_id: &str,
2657 body: &m::UpdateNATGatewayBody,
2658 ) -> Request<m::UpdateNATGatewayResponse> {
2659 Request::new(Core::new(
2660 self.client.clone(),
2661 "network",
2662 ENDPOINT,
2663 &OP_70,
2664 &[("nat_gateway_id", nat_gateway_id)],
2665 Payload::json(body),
2666 Ok(serde_json::json!({})),
2667 ))
2668 }
2669 pub fn update_route(
2671 &self,
2672 route_table_id: &str,
2673 route_id: &str,
2674 body: &m::UpdateRouteBody,
2675 ) -> Request<m::UpdateRouteResponse> {
2676 Request::new(Core::new(
2677 self.client.clone(),
2678 "network",
2679 ENDPOINT,
2680 &OP_71,
2681 &[("route_table_id", route_table_id), ("route_id", route_id)],
2682 Payload::json(body),
2683 Ok(serde_json::json!({})),
2684 ))
2685 }
2686 pub fn update_route_table(
2688 &self,
2689 route_table_id: &str,
2690 body: &m::UpdateRouteTableBody,
2691 ) -> Request<m::UpdateRouteTableResponse> {
2692 Request::new(Core::new(
2693 self.client.clone(),
2694 "network",
2695 ENDPOINT,
2696 &OP_72,
2697 &[("route_table_id", route_table_id)],
2698 Payload::json(body),
2699 Ok(serde_json::json!({})),
2700 ))
2701 }
2702 pub fn update_security_group(
2704 &self,
2705 security_group_id: &str,
2706 body: &m::UpdateSecurityGroupBody,
2707 ) -> Request<m::UpdateSecurityGroupResponse> {
2708 Request::new(Core::new(
2709 self.client.clone(),
2710 "network",
2711 ENDPOINT,
2712 &OP_73,
2713 &[("security_group_id", security_group_id)],
2714 Payload::json(body),
2715 Ok(serde_json::json!({})),
2716 ))
2717 }
2718 pub fn update_subnet(
2720 &self,
2721 subnet_id: &str,
2722 body: &m::UpdateSubnetBody,
2723 ) -> Request<m::UpdateSubnetResponse> {
2724 Request::new(Core::new(
2725 self.client.clone(),
2726 "network",
2727 ENDPOINT,
2728 &OP_74,
2729 &[("subnet_id", subnet_id)],
2730 Payload::json(body),
2731 Ok(serde_json::json!({})),
2732 ))
2733 }
2734 pub fn update_vpc(
2736 &self,
2737 vpc_id: &str,
2738 body: &m::UpdateVpcBody,
2739 ) -> Request<m::UpdateVpcResponse> {
2740 Request::new(Core::new(
2741 self.client.clone(),
2742 "network",
2743 ENDPOINT,
2744 &OP_75,
2745 &[("vpc_id", vpc_id)],
2746 Payload::json(body),
2747 Ok(serde_json::json!({})),
2748 ))
2749 }
2750}