Skip to main content

basaltic/services/
network.rs

1//! Generated API methods; do not edit.
2#![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    /// Attach an interface to a floating IP
1220    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    /// Attach a security group to an interface
1236    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    /// Create egress-only gateway
1252    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    /// Allocate floating IP
1267    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    /// Create interface
1282    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    /// Create interface address
1297    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    /// Create interface prefix
1313    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    /// Create internet gateway
1329    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    /// Create NAT gateway
1344    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    /// Create prefix pool
1359    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    /// Create route
1375    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    /// Create route table
1391    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    /// Create security group
1406    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    /// Create security group rule
1421    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    /// Create subnet
1437    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    /// Create VPC
1449    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    /// Delete egress-only gateway
1461    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    /// Release floating IP
1473    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    /// Delete interface
1485    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    /// Delete interface address
1497    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    /// Delete interface prefix
1509    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    /// Delete internet gateway
1521    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    /// Delete NAT gateway
1533    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    /// Delete prefix pool
1545    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    /// Delete route
1557    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    /// Delete route table
1569    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    /// Delete security group
1581    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    /// Delete security group rule
1593    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    /// Delete subnet
1612    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    /// Delete VPC
1624    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    /// Detach all direct interfaces from a floating IP
1636    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    /// Detach an interface from a floating IP
1648    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    /// Detach a security group from an interface
1667    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    /// Enable IPv6 on a subnet
1686    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    /// Enable IPv6 on a vpc
1702    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    /// Get egress-only gateway
1718    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1733    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    /// Get floating IP
1765    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1777    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    /// Get interface
1809    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1821    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    /// Get interface address
1853    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    /// Get internet gateway
1869    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1884    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    /// Get NAT gateway
1916    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1928    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    /// Get route
1960    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1972    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    /// Get route table
2005    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
2017    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    /// Get security group
2049    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
2064    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    /// Get security group rule
2096    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
2115    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    /// Get subnet
2151    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
2163    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    /// Get VPC
2195    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
2207    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    /// List egress-only gateway routes
2239    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    /// List egress-only gateways
2259    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    /// List a floating IP’s interfaces
2277    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    /// List floating IPs
2296    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    /// List interface addresses
2314    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    /// List interface prefixes
2332    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    /// List an interface’s security groups
2350    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    /// List interfaces
2370    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    /// List internet gateway routes
2388    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    /// List internet gateways
2407    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    /// List NAT gateway routes
2425    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    /// List NAT gateways
2444    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    /// List prefix pools
2462    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    /// List route tables
2480    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    /// List routes
2498    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    /// List security group rules
2517    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    /// List security groups
2536    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    /// List subnets
2554    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    /// List VPCs
2572    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    /// Update egress-only gateway
2590    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    /// Update floating IP
2606    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    /// Update interface
2622    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    /// Update internet gateway
2638    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    /// Update NAT gateway
2654    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    /// Update route
2670    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    /// Update route table
2687    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    /// Update security group
2703    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    /// Update subnet
2719    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    /// Update VPC
2735    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}