nautobot_openapi/apis/
ipam_api.rs

1/*
2 * API Documentation
3 *
4 * Source of truth and network automation platform
5 *
6 * The version of the OpenAPI document: 3.1.0 (3.1)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`ipam_ip_address_to_interface_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum IpamIpAddressToInterfaceBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`ipam_ip_address_to_interface_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum IpamIpAddressToInterfaceBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`ipam_ip_address_to_interface_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum IpamIpAddressToInterfaceBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`ipam_ip_address_to_interface_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum IpamIpAddressToInterfaceCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`ipam_ip_address_to_interface_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum IpamIpAddressToInterfaceDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`ipam_ip_address_to_interface_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum IpamIpAddressToInterfaceListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`ipam_ip_address_to_interface_notes_create`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum IpamIpAddressToInterfaceNotesCreateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`ipam_ip_address_to_interface_notes_list`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum IpamIpAddressToInterfaceNotesListError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`ipam_ip_address_to_interface_partial_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum IpamIpAddressToInterfacePartialUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`ipam_ip_address_to_interface_retrieve`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum IpamIpAddressToInterfaceRetrieveError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`ipam_ip_address_to_interface_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum IpamIpAddressToInterfaceUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`ipam_ip_addresses_bulk_destroy`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum IpamIpAddressesBulkDestroyError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`ipam_ip_addresses_bulk_partial_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum IpamIpAddressesBulkPartialUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`ipam_ip_addresses_bulk_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum IpamIpAddressesBulkUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`ipam_ip_addresses_create`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum IpamIpAddressesCreateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`ipam_ip_addresses_destroy`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum IpamIpAddressesDestroyError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`ipam_ip_addresses_list`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum IpamIpAddressesListError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`ipam_ip_addresses_notes_create`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum IpamIpAddressesNotesCreateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`ipam_ip_addresses_notes_list`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum IpamIpAddressesNotesListError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`ipam_ip_addresses_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum IpamIpAddressesPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`ipam_ip_addresses_retrieve`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum IpamIpAddressesRetrieveError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`ipam_ip_addresses_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum IpamIpAddressesUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`ipam_namespaces_bulk_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum IpamNamespacesBulkDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`ipam_namespaces_bulk_partial_update`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum IpamNamespacesBulkPartialUpdateError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`ipam_namespaces_bulk_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum IpamNamespacesBulkUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`ipam_namespaces_create`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum IpamNamespacesCreateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`ipam_namespaces_destroy`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum IpamNamespacesDestroyError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`ipam_namespaces_list`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum IpamNamespacesListError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`ipam_namespaces_notes_create`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum IpamNamespacesNotesCreateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`ipam_namespaces_notes_list`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum IpamNamespacesNotesListError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`ipam_namespaces_partial_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum IpamNamespacesPartialUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`ipam_namespaces_retrieve`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum IpamNamespacesRetrieveError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`ipam_namespaces_update`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum IpamNamespacesUpdateError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`ipam_prefix_location_assignments_bulk_destroy`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum IpamPrefixLocationAssignmentsBulkDestroyError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`ipam_prefix_location_assignments_bulk_partial_update`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum IpamPrefixLocationAssignmentsBulkPartialUpdateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`ipam_prefix_location_assignments_bulk_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum IpamPrefixLocationAssignmentsBulkUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`ipam_prefix_location_assignments_create`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum IpamPrefixLocationAssignmentsCreateError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`ipam_prefix_location_assignments_destroy`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum IpamPrefixLocationAssignmentsDestroyError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`ipam_prefix_location_assignments_list`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum IpamPrefixLocationAssignmentsListError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`ipam_prefix_location_assignments_partial_update`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum IpamPrefixLocationAssignmentsPartialUpdateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`ipam_prefix_location_assignments_retrieve`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum IpamPrefixLocationAssignmentsRetrieveError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`ipam_prefix_location_assignments_update`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum IpamPrefixLocationAssignmentsUpdateError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`ipam_prefixes_available_ips_create`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum IpamPrefixesAvailableIpsCreateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`ipam_prefixes_available_ips_list`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum IpamPrefixesAvailableIpsListError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`ipam_prefixes_available_prefixes_create`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum IpamPrefixesAvailablePrefixesCreateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`ipam_prefixes_available_prefixes_list`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum IpamPrefixesAvailablePrefixesListError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`ipam_prefixes_bulk_destroy`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum IpamPrefixesBulkDestroyError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`ipam_prefixes_bulk_partial_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum IpamPrefixesBulkPartialUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`ipam_prefixes_bulk_update`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum IpamPrefixesBulkUpdateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`ipam_prefixes_create`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum IpamPrefixesCreateError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`ipam_prefixes_destroy`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum IpamPrefixesDestroyError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`ipam_prefixes_list`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum IpamPrefixesListError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`ipam_prefixes_notes_create`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum IpamPrefixesNotesCreateError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`ipam_prefixes_notes_list`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum IpamPrefixesNotesListError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`ipam_prefixes_partial_update`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum IpamPrefixesPartialUpdateError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`ipam_prefixes_retrieve`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum IpamPrefixesRetrieveError {
405    UnknownValue(serde_json::Value),
406}
407
408/// struct for typed errors of method [`ipam_prefixes_update`]
409#[derive(Debug, Clone, Serialize, Deserialize)]
410#[serde(untagged)]
411pub enum IpamPrefixesUpdateError {
412    UnknownValue(serde_json::Value),
413}
414
415/// struct for typed errors of method [`ipam_rirs_bulk_destroy`]
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(untagged)]
418pub enum IpamRirsBulkDestroyError {
419    UnknownValue(serde_json::Value),
420}
421
422/// struct for typed errors of method [`ipam_rirs_bulk_partial_update`]
423#[derive(Debug, Clone, Serialize, Deserialize)]
424#[serde(untagged)]
425pub enum IpamRirsBulkPartialUpdateError {
426    UnknownValue(serde_json::Value),
427}
428
429/// struct for typed errors of method [`ipam_rirs_bulk_update`]
430#[derive(Debug, Clone, Serialize, Deserialize)]
431#[serde(untagged)]
432pub enum IpamRirsBulkUpdateError {
433    UnknownValue(serde_json::Value),
434}
435
436/// struct for typed errors of method [`ipam_rirs_create`]
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[serde(untagged)]
439pub enum IpamRirsCreateError {
440    UnknownValue(serde_json::Value),
441}
442
443/// struct for typed errors of method [`ipam_rirs_destroy`]
444#[derive(Debug, Clone, Serialize, Deserialize)]
445#[serde(untagged)]
446pub enum IpamRirsDestroyError {
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`ipam_rirs_list`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum IpamRirsListError {
454    UnknownValue(serde_json::Value),
455}
456
457/// struct for typed errors of method [`ipam_rirs_notes_create`]
458#[derive(Debug, Clone, Serialize, Deserialize)]
459#[serde(untagged)]
460pub enum IpamRirsNotesCreateError {
461    UnknownValue(serde_json::Value),
462}
463
464/// struct for typed errors of method [`ipam_rirs_notes_list`]
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(untagged)]
467pub enum IpamRirsNotesListError {
468    UnknownValue(serde_json::Value),
469}
470
471/// struct for typed errors of method [`ipam_rirs_partial_update`]
472#[derive(Debug, Clone, Serialize, Deserialize)]
473#[serde(untagged)]
474pub enum IpamRirsPartialUpdateError {
475    UnknownValue(serde_json::Value),
476}
477
478/// struct for typed errors of method [`ipam_rirs_retrieve`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum IpamRirsRetrieveError {
482    UnknownValue(serde_json::Value),
483}
484
485/// struct for typed errors of method [`ipam_rirs_update`]
486#[derive(Debug, Clone, Serialize, Deserialize)]
487#[serde(untagged)]
488pub enum IpamRirsUpdateError {
489    UnknownValue(serde_json::Value),
490}
491
492/// struct for typed errors of method [`ipam_route_targets_bulk_destroy`]
493#[derive(Debug, Clone, Serialize, Deserialize)]
494#[serde(untagged)]
495pub enum IpamRouteTargetsBulkDestroyError {
496    UnknownValue(serde_json::Value),
497}
498
499/// struct for typed errors of method [`ipam_route_targets_bulk_partial_update`]
500#[derive(Debug, Clone, Serialize, Deserialize)]
501#[serde(untagged)]
502pub enum IpamRouteTargetsBulkPartialUpdateError {
503    UnknownValue(serde_json::Value),
504}
505
506/// struct for typed errors of method [`ipam_route_targets_bulk_update`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum IpamRouteTargetsBulkUpdateError {
510    UnknownValue(serde_json::Value),
511}
512
513/// struct for typed errors of method [`ipam_route_targets_create`]
514#[derive(Debug, Clone, Serialize, Deserialize)]
515#[serde(untagged)]
516pub enum IpamRouteTargetsCreateError {
517    UnknownValue(serde_json::Value),
518}
519
520/// struct for typed errors of method [`ipam_route_targets_destroy`]
521#[derive(Debug, Clone, Serialize, Deserialize)]
522#[serde(untagged)]
523pub enum IpamRouteTargetsDestroyError {
524    UnknownValue(serde_json::Value),
525}
526
527/// struct for typed errors of method [`ipam_route_targets_list`]
528#[derive(Debug, Clone, Serialize, Deserialize)]
529#[serde(untagged)]
530pub enum IpamRouteTargetsListError {
531    UnknownValue(serde_json::Value),
532}
533
534/// struct for typed errors of method [`ipam_route_targets_notes_create`]
535#[derive(Debug, Clone, Serialize, Deserialize)]
536#[serde(untagged)]
537pub enum IpamRouteTargetsNotesCreateError {
538    UnknownValue(serde_json::Value),
539}
540
541/// struct for typed errors of method [`ipam_route_targets_notes_list`]
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(untagged)]
544pub enum IpamRouteTargetsNotesListError {
545    UnknownValue(serde_json::Value),
546}
547
548/// struct for typed errors of method [`ipam_route_targets_partial_update`]
549#[derive(Debug, Clone, Serialize, Deserialize)]
550#[serde(untagged)]
551pub enum IpamRouteTargetsPartialUpdateError {
552    UnknownValue(serde_json::Value),
553}
554
555/// struct for typed errors of method [`ipam_route_targets_retrieve`]
556#[derive(Debug, Clone, Serialize, Deserialize)]
557#[serde(untagged)]
558pub enum IpamRouteTargetsRetrieveError {
559    UnknownValue(serde_json::Value),
560}
561
562/// struct for typed errors of method [`ipam_route_targets_update`]
563#[derive(Debug, Clone, Serialize, Deserialize)]
564#[serde(untagged)]
565pub enum IpamRouteTargetsUpdateError {
566    UnknownValue(serde_json::Value),
567}
568
569/// struct for typed errors of method [`ipam_services_bulk_destroy`]
570#[derive(Debug, Clone, Serialize, Deserialize)]
571#[serde(untagged)]
572pub enum IpamServicesBulkDestroyError {
573    UnknownValue(serde_json::Value),
574}
575
576/// struct for typed errors of method [`ipam_services_bulk_partial_update`]
577#[derive(Debug, Clone, Serialize, Deserialize)]
578#[serde(untagged)]
579pub enum IpamServicesBulkPartialUpdateError {
580    UnknownValue(serde_json::Value),
581}
582
583/// struct for typed errors of method [`ipam_services_bulk_update`]
584#[derive(Debug, Clone, Serialize, Deserialize)]
585#[serde(untagged)]
586pub enum IpamServicesBulkUpdateError {
587    UnknownValue(serde_json::Value),
588}
589
590/// struct for typed errors of method [`ipam_services_create`]
591#[derive(Debug, Clone, Serialize, Deserialize)]
592#[serde(untagged)]
593pub enum IpamServicesCreateError {
594    UnknownValue(serde_json::Value),
595}
596
597/// struct for typed errors of method [`ipam_services_destroy`]
598#[derive(Debug, Clone, Serialize, Deserialize)]
599#[serde(untagged)]
600pub enum IpamServicesDestroyError {
601    UnknownValue(serde_json::Value),
602}
603
604/// struct for typed errors of method [`ipam_services_list`]
605#[derive(Debug, Clone, Serialize, Deserialize)]
606#[serde(untagged)]
607pub enum IpamServicesListError {
608    UnknownValue(serde_json::Value),
609}
610
611/// struct for typed errors of method [`ipam_services_notes_create`]
612#[derive(Debug, Clone, Serialize, Deserialize)]
613#[serde(untagged)]
614pub enum IpamServicesNotesCreateError {
615    UnknownValue(serde_json::Value),
616}
617
618/// struct for typed errors of method [`ipam_services_notes_list`]
619#[derive(Debug, Clone, Serialize, Deserialize)]
620#[serde(untagged)]
621pub enum IpamServicesNotesListError {
622    UnknownValue(serde_json::Value),
623}
624
625/// struct for typed errors of method [`ipam_services_partial_update`]
626#[derive(Debug, Clone, Serialize, Deserialize)]
627#[serde(untagged)]
628pub enum IpamServicesPartialUpdateError {
629    UnknownValue(serde_json::Value),
630}
631
632/// struct for typed errors of method [`ipam_services_retrieve`]
633#[derive(Debug, Clone, Serialize, Deserialize)]
634#[serde(untagged)]
635pub enum IpamServicesRetrieveError {
636    UnknownValue(serde_json::Value),
637}
638
639/// struct for typed errors of method [`ipam_services_update`]
640#[derive(Debug, Clone, Serialize, Deserialize)]
641#[serde(untagged)]
642pub enum IpamServicesUpdateError {
643    UnknownValue(serde_json::Value),
644}
645
646/// struct for typed errors of method [`ipam_vlan_groups_available_vlans_create`]
647#[derive(Debug, Clone, Serialize, Deserialize)]
648#[serde(untagged)]
649pub enum IpamVlanGroupsAvailableVlansCreateError {
650    UnknownValue(serde_json::Value),
651}
652
653/// struct for typed errors of method [`ipam_vlan_groups_available_vlans_list`]
654#[derive(Debug, Clone, Serialize, Deserialize)]
655#[serde(untagged)]
656pub enum IpamVlanGroupsAvailableVlansListError {
657    UnknownValue(serde_json::Value),
658}
659
660/// struct for typed errors of method [`ipam_vlan_groups_bulk_destroy`]
661#[derive(Debug, Clone, Serialize, Deserialize)]
662#[serde(untagged)]
663pub enum IpamVlanGroupsBulkDestroyError {
664    UnknownValue(serde_json::Value),
665}
666
667/// struct for typed errors of method [`ipam_vlan_groups_bulk_partial_update`]
668#[derive(Debug, Clone, Serialize, Deserialize)]
669#[serde(untagged)]
670pub enum IpamVlanGroupsBulkPartialUpdateError {
671    UnknownValue(serde_json::Value),
672}
673
674/// struct for typed errors of method [`ipam_vlan_groups_bulk_update`]
675#[derive(Debug, Clone, Serialize, Deserialize)]
676#[serde(untagged)]
677pub enum IpamVlanGroupsBulkUpdateError {
678    UnknownValue(serde_json::Value),
679}
680
681/// struct for typed errors of method [`ipam_vlan_groups_create`]
682#[derive(Debug, Clone, Serialize, Deserialize)]
683#[serde(untagged)]
684pub enum IpamVlanGroupsCreateError {
685    UnknownValue(serde_json::Value),
686}
687
688/// struct for typed errors of method [`ipam_vlan_groups_destroy`]
689#[derive(Debug, Clone, Serialize, Deserialize)]
690#[serde(untagged)]
691pub enum IpamVlanGroupsDestroyError {
692    UnknownValue(serde_json::Value),
693}
694
695/// struct for typed errors of method [`ipam_vlan_groups_list`]
696#[derive(Debug, Clone, Serialize, Deserialize)]
697#[serde(untagged)]
698pub enum IpamVlanGroupsListError {
699    UnknownValue(serde_json::Value),
700}
701
702/// struct for typed errors of method [`ipam_vlan_groups_notes_create`]
703#[derive(Debug, Clone, Serialize, Deserialize)]
704#[serde(untagged)]
705pub enum IpamVlanGroupsNotesCreateError {
706    UnknownValue(serde_json::Value),
707}
708
709/// struct for typed errors of method [`ipam_vlan_groups_notes_list`]
710#[derive(Debug, Clone, Serialize, Deserialize)]
711#[serde(untagged)]
712pub enum IpamVlanGroupsNotesListError {
713    UnknownValue(serde_json::Value),
714}
715
716/// struct for typed errors of method [`ipam_vlan_groups_partial_update`]
717#[derive(Debug, Clone, Serialize, Deserialize)]
718#[serde(untagged)]
719pub enum IpamVlanGroupsPartialUpdateError {
720    UnknownValue(serde_json::Value),
721}
722
723/// struct for typed errors of method [`ipam_vlan_groups_retrieve`]
724#[derive(Debug, Clone, Serialize, Deserialize)]
725#[serde(untagged)]
726pub enum IpamVlanGroupsRetrieveError {
727    UnknownValue(serde_json::Value),
728}
729
730/// struct for typed errors of method [`ipam_vlan_groups_update`]
731#[derive(Debug, Clone, Serialize, Deserialize)]
732#[serde(untagged)]
733pub enum IpamVlanGroupsUpdateError {
734    UnknownValue(serde_json::Value),
735}
736
737/// struct for typed errors of method [`ipam_vlan_location_assignments_bulk_destroy`]
738#[derive(Debug, Clone, Serialize, Deserialize)]
739#[serde(untagged)]
740pub enum IpamVlanLocationAssignmentsBulkDestroyError {
741    UnknownValue(serde_json::Value),
742}
743
744/// struct for typed errors of method [`ipam_vlan_location_assignments_bulk_partial_update`]
745#[derive(Debug, Clone, Serialize, Deserialize)]
746#[serde(untagged)]
747pub enum IpamVlanLocationAssignmentsBulkPartialUpdateError {
748    UnknownValue(serde_json::Value),
749}
750
751/// struct for typed errors of method [`ipam_vlan_location_assignments_bulk_update`]
752#[derive(Debug, Clone, Serialize, Deserialize)]
753#[serde(untagged)]
754pub enum IpamVlanLocationAssignmentsBulkUpdateError {
755    UnknownValue(serde_json::Value),
756}
757
758/// struct for typed errors of method [`ipam_vlan_location_assignments_create`]
759#[derive(Debug, Clone, Serialize, Deserialize)]
760#[serde(untagged)]
761pub enum IpamVlanLocationAssignmentsCreateError {
762    UnknownValue(serde_json::Value),
763}
764
765/// struct for typed errors of method [`ipam_vlan_location_assignments_destroy`]
766#[derive(Debug, Clone, Serialize, Deserialize)]
767#[serde(untagged)]
768pub enum IpamVlanLocationAssignmentsDestroyError {
769    UnknownValue(serde_json::Value),
770}
771
772/// struct for typed errors of method [`ipam_vlan_location_assignments_list`]
773#[derive(Debug, Clone, Serialize, Deserialize)]
774#[serde(untagged)]
775pub enum IpamVlanLocationAssignmentsListError {
776    UnknownValue(serde_json::Value),
777}
778
779/// struct for typed errors of method [`ipam_vlan_location_assignments_partial_update`]
780#[derive(Debug, Clone, Serialize, Deserialize)]
781#[serde(untagged)]
782pub enum IpamVlanLocationAssignmentsPartialUpdateError {
783    UnknownValue(serde_json::Value),
784}
785
786/// struct for typed errors of method [`ipam_vlan_location_assignments_retrieve`]
787#[derive(Debug, Clone, Serialize, Deserialize)]
788#[serde(untagged)]
789pub enum IpamVlanLocationAssignmentsRetrieveError {
790    UnknownValue(serde_json::Value),
791}
792
793/// struct for typed errors of method [`ipam_vlan_location_assignments_update`]
794#[derive(Debug, Clone, Serialize, Deserialize)]
795#[serde(untagged)]
796pub enum IpamVlanLocationAssignmentsUpdateError {
797    UnknownValue(serde_json::Value),
798}
799
800/// struct for typed errors of method [`ipam_vlans_bulk_destroy`]
801#[derive(Debug, Clone, Serialize, Deserialize)]
802#[serde(untagged)]
803pub enum IpamVlansBulkDestroyError {
804    UnknownValue(serde_json::Value),
805}
806
807/// struct for typed errors of method [`ipam_vlans_bulk_partial_update`]
808#[derive(Debug, Clone, Serialize, Deserialize)]
809#[serde(untagged)]
810pub enum IpamVlansBulkPartialUpdateError {
811    UnknownValue(serde_json::Value),
812}
813
814/// struct for typed errors of method [`ipam_vlans_bulk_update`]
815#[derive(Debug, Clone, Serialize, Deserialize)]
816#[serde(untagged)]
817pub enum IpamVlansBulkUpdateError {
818    UnknownValue(serde_json::Value),
819}
820
821/// struct for typed errors of method [`ipam_vlans_create`]
822#[derive(Debug, Clone, Serialize, Deserialize)]
823#[serde(untagged)]
824pub enum IpamVlansCreateError {
825    UnknownValue(serde_json::Value),
826}
827
828/// struct for typed errors of method [`ipam_vlans_destroy`]
829#[derive(Debug, Clone, Serialize, Deserialize)]
830#[serde(untagged)]
831pub enum IpamVlansDestroyError {
832    UnknownValue(serde_json::Value),
833}
834
835/// struct for typed errors of method [`ipam_vlans_list`]
836#[derive(Debug, Clone, Serialize, Deserialize)]
837#[serde(untagged)]
838pub enum IpamVlansListError {
839    UnknownValue(serde_json::Value),
840}
841
842/// struct for typed errors of method [`ipam_vlans_notes_create`]
843#[derive(Debug, Clone, Serialize, Deserialize)]
844#[serde(untagged)]
845pub enum IpamVlansNotesCreateError {
846    UnknownValue(serde_json::Value),
847}
848
849/// struct for typed errors of method [`ipam_vlans_notes_list`]
850#[derive(Debug, Clone, Serialize, Deserialize)]
851#[serde(untagged)]
852pub enum IpamVlansNotesListError {
853    UnknownValue(serde_json::Value),
854}
855
856/// struct for typed errors of method [`ipam_vlans_partial_update`]
857#[derive(Debug, Clone, Serialize, Deserialize)]
858#[serde(untagged)]
859pub enum IpamVlansPartialUpdateError {
860    UnknownValue(serde_json::Value),
861}
862
863/// struct for typed errors of method [`ipam_vlans_retrieve`]
864#[derive(Debug, Clone, Serialize, Deserialize)]
865#[serde(untagged)]
866pub enum IpamVlansRetrieveError {
867    UnknownValue(serde_json::Value),
868}
869
870/// struct for typed errors of method [`ipam_vlans_update`]
871#[derive(Debug, Clone, Serialize, Deserialize)]
872#[serde(untagged)]
873pub enum IpamVlansUpdateError {
874    UnknownValue(serde_json::Value),
875}
876
877/// struct for typed errors of method [`ipam_vrf_device_assignments_bulk_destroy`]
878#[derive(Debug, Clone, Serialize, Deserialize)]
879#[serde(untagged)]
880pub enum IpamVrfDeviceAssignmentsBulkDestroyError {
881    UnknownValue(serde_json::Value),
882}
883
884/// struct for typed errors of method [`ipam_vrf_device_assignments_bulk_partial_update`]
885#[derive(Debug, Clone, Serialize, Deserialize)]
886#[serde(untagged)]
887pub enum IpamVrfDeviceAssignmentsBulkPartialUpdateError {
888    UnknownValue(serde_json::Value),
889}
890
891/// struct for typed errors of method [`ipam_vrf_device_assignments_bulk_update`]
892#[derive(Debug, Clone, Serialize, Deserialize)]
893#[serde(untagged)]
894pub enum IpamVrfDeviceAssignmentsBulkUpdateError {
895    UnknownValue(serde_json::Value),
896}
897
898/// struct for typed errors of method [`ipam_vrf_device_assignments_create`]
899#[derive(Debug, Clone, Serialize, Deserialize)]
900#[serde(untagged)]
901pub enum IpamVrfDeviceAssignmentsCreateError {
902    UnknownValue(serde_json::Value),
903}
904
905/// struct for typed errors of method [`ipam_vrf_device_assignments_destroy`]
906#[derive(Debug, Clone, Serialize, Deserialize)]
907#[serde(untagged)]
908pub enum IpamVrfDeviceAssignmentsDestroyError {
909    UnknownValue(serde_json::Value),
910}
911
912/// struct for typed errors of method [`ipam_vrf_device_assignments_list`]
913#[derive(Debug, Clone, Serialize, Deserialize)]
914#[serde(untagged)]
915pub enum IpamVrfDeviceAssignmentsListError {
916    UnknownValue(serde_json::Value),
917}
918
919/// struct for typed errors of method [`ipam_vrf_device_assignments_partial_update`]
920#[derive(Debug, Clone, Serialize, Deserialize)]
921#[serde(untagged)]
922pub enum IpamVrfDeviceAssignmentsPartialUpdateError {
923    UnknownValue(serde_json::Value),
924}
925
926/// struct for typed errors of method [`ipam_vrf_device_assignments_retrieve`]
927#[derive(Debug, Clone, Serialize, Deserialize)]
928#[serde(untagged)]
929pub enum IpamVrfDeviceAssignmentsRetrieveError {
930    UnknownValue(serde_json::Value),
931}
932
933/// struct for typed errors of method [`ipam_vrf_device_assignments_update`]
934#[derive(Debug, Clone, Serialize, Deserialize)]
935#[serde(untagged)]
936pub enum IpamVrfDeviceAssignmentsUpdateError {
937    UnknownValue(serde_json::Value),
938}
939
940/// struct for typed errors of method [`ipam_vrf_prefix_assignments_bulk_destroy`]
941#[derive(Debug, Clone, Serialize, Deserialize)]
942#[serde(untagged)]
943pub enum IpamVrfPrefixAssignmentsBulkDestroyError {
944    UnknownValue(serde_json::Value),
945}
946
947/// struct for typed errors of method [`ipam_vrf_prefix_assignments_bulk_partial_update`]
948#[derive(Debug, Clone, Serialize, Deserialize)]
949#[serde(untagged)]
950pub enum IpamVrfPrefixAssignmentsBulkPartialUpdateError {
951    UnknownValue(serde_json::Value),
952}
953
954/// struct for typed errors of method [`ipam_vrf_prefix_assignments_bulk_update`]
955#[derive(Debug, Clone, Serialize, Deserialize)]
956#[serde(untagged)]
957pub enum IpamVrfPrefixAssignmentsBulkUpdateError {
958    UnknownValue(serde_json::Value),
959}
960
961/// struct for typed errors of method [`ipam_vrf_prefix_assignments_create`]
962#[derive(Debug, Clone, Serialize, Deserialize)]
963#[serde(untagged)]
964pub enum IpamVrfPrefixAssignmentsCreateError {
965    UnknownValue(serde_json::Value),
966}
967
968/// struct for typed errors of method [`ipam_vrf_prefix_assignments_destroy`]
969#[derive(Debug, Clone, Serialize, Deserialize)]
970#[serde(untagged)]
971pub enum IpamVrfPrefixAssignmentsDestroyError {
972    UnknownValue(serde_json::Value),
973}
974
975/// struct for typed errors of method [`ipam_vrf_prefix_assignments_list`]
976#[derive(Debug, Clone, Serialize, Deserialize)]
977#[serde(untagged)]
978pub enum IpamVrfPrefixAssignmentsListError {
979    UnknownValue(serde_json::Value),
980}
981
982/// struct for typed errors of method [`ipam_vrf_prefix_assignments_partial_update`]
983#[derive(Debug, Clone, Serialize, Deserialize)]
984#[serde(untagged)]
985pub enum IpamVrfPrefixAssignmentsPartialUpdateError {
986    UnknownValue(serde_json::Value),
987}
988
989/// struct for typed errors of method [`ipam_vrf_prefix_assignments_retrieve`]
990#[derive(Debug, Clone, Serialize, Deserialize)]
991#[serde(untagged)]
992pub enum IpamVrfPrefixAssignmentsRetrieveError {
993    UnknownValue(serde_json::Value),
994}
995
996/// struct for typed errors of method [`ipam_vrf_prefix_assignments_update`]
997#[derive(Debug, Clone, Serialize, Deserialize)]
998#[serde(untagged)]
999pub enum IpamVrfPrefixAssignmentsUpdateError {
1000    UnknownValue(serde_json::Value),
1001}
1002
1003/// struct for typed errors of method [`ipam_vrfs_bulk_destroy`]
1004#[derive(Debug, Clone, Serialize, Deserialize)]
1005#[serde(untagged)]
1006pub enum IpamVrfsBulkDestroyError {
1007    UnknownValue(serde_json::Value),
1008}
1009
1010/// struct for typed errors of method [`ipam_vrfs_bulk_partial_update`]
1011#[derive(Debug, Clone, Serialize, Deserialize)]
1012#[serde(untagged)]
1013pub enum IpamVrfsBulkPartialUpdateError {
1014    UnknownValue(serde_json::Value),
1015}
1016
1017/// struct for typed errors of method [`ipam_vrfs_bulk_update`]
1018#[derive(Debug, Clone, Serialize, Deserialize)]
1019#[serde(untagged)]
1020pub enum IpamVrfsBulkUpdateError {
1021    UnknownValue(serde_json::Value),
1022}
1023
1024/// struct for typed errors of method [`ipam_vrfs_create`]
1025#[derive(Debug, Clone, Serialize, Deserialize)]
1026#[serde(untagged)]
1027pub enum IpamVrfsCreateError {
1028    UnknownValue(serde_json::Value),
1029}
1030
1031/// struct for typed errors of method [`ipam_vrfs_destroy`]
1032#[derive(Debug, Clone, Serialize, Deserialize)]
1033#[serde(untagged)]
1034pub enum IpamVrfsDestroyError {
1035    UnknownValue(serde_json::Value),
1036}
1037
1038/// struct for typed errors of method [`ipam_vrfs_list`]
1039#[derive(Debug, Clone, Serialize, Deserialize)]
1040#[serde(untagged)]
1041pub enum IpamVrfsListError {
1042    UnknownValue(serde_json::Value),
1043}
1044
1045/// struct for typed errors of method [`ipam_vrfs_notes_create`]
1046#[derive(Debug, Clone, Serialize, Deserialize)]
1047#[serde(untagged)]
1048pub enum IpamVrfsNotesCreateError {
1049    UnknownValue(serde_json::Value),
1050}
1051
1052/// struct for typed errors of method [`ipam_vrfs_notes_list`]
1053#[derive(Debug, Clone, Serialize, Deserialize)]
1054#[serde(untagged)]
1055pub enum IpamVrfsNotesListError {
1056    UnknownValue(serde_json::Value),
1057}
1058
1059/// struct for typed errors of method [`ipam_vrfs_partial_update`]
1060#[derive(Debug, Clone, Serialize, Deserialize)]
1061#[serde(untagged)]
1062pub enum IpamVrfsPartialUpdateError {
1063    UnknownValue(serde_json::Value),
1064}
1065
1066/// struct for typed errors of method [`ipam_vrfs_retrieve`]
1067#[derive(Debug, Clone, Serialize, Deserialize)]
1068#[serde(untagged)]
1069pub enum IpamVrfsRetrieveError {
1070    UnknownValue(serde_json::Value),
1071}
1072
1073/// struct for typed errors of method [`ipam_vrfs_update`]
1074#[derive(Debug, Clone, Serialize, Deserialize)]
1075#[serde(untagged)]
1076pub enum IpamVrfsUpdateError {
1077    UnknownValue(serde_json::Value),
1078}
1079
1080/// Destroy a list of IP Address Assignment objects.
1081pub async fn ipam_ip_address_to_interface_bulk_destroy(
1082    configuration: &configuration::Configuration,
1083    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
1084    format: Option<&str>,
1085) -> Result<(), Error<IpamIpAddressToInterfaceBulkDestroyError>> {
1086    let local_var_configuration = configuration;
1087
1088    let local_var_client = &local_var_configuration.client;
1089
1090    let local_var_uri_str = format!(
1091        "{}/ipam/ip-address-to-interface/",
1092        local_var_configuration.base_path
1093    );
1094    let mut local_var_req_builder =
1095        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1096
1097    if let Some(ref local_var_str) = format {
1098        local_var_req_builder =
1099            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1100    }
1101    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1102        local_var_req_builder =
1103            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1104    }
1105    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1106        let local_var_key = local_var_apikey.key.clone();
1107        let local_var_value = match local_var_apikey.prefix {
1108            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1109            None => local_var_key,
1110        };
1111        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1112    };
1113    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
1114
1115    let local_var_req = local_var_req_builder.build()?;
1116    let local_var_resp = local_var_client.execute(local_var_req).await?;
1117
1118    let local_var_status = local_var_resp.status();
1119    let local_var_content = local_var_resp.text().await?;
1120
1121    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1122        Ok(())
1123    } else {
1124        let local_var_entity: Option<IpamIpAddressToInterfaceBulkDestroyError> =
1125            serde_json::from_str(&local_var_content).ok();
1126        let local_var_error = ResponseContent {
1127            status: local_var_status,
1128            content: local_var_content,
1129            entity: local_var_entity,
1130        };
1131        Err(Error::ResponseError(local_var_error))
1132    }
1133}
1134
1135/// Partial update a list of IP Address Assignment objects.
1136pub async fn ipam_ip_address_to_interface_bulk_partial_update(
1137    configuration: &configuration::Configuration,
1138    patched_bulk_writable_ip_address_to_interface_request: Vec<
1139        crate::models::PatchedBulkWritableIpAddressToInterfaceRequest,
1140    >,
1141    format: Option<&str>,
1142) -> Result<
1143    Vec<crate::models::IpAddressToInterface>,
1144    Error<IpamIpAddressToInterfaceBulkPartialUpdateError>,
1145> {
1146    let local_var_configuration = configuration;
1147
1148    let local_var_client = &local_var_configuration.client;
1149
1150    let local_var_uri_str = format!(
1151        "{}/ipam/ip-address-to-interface/",
1152        local_var_configuration.base_path
1153    );
1154    let mut local_var_req_builder =
1155        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1156
1157    if let Some(ref local_var_str) = format {
1158        local_var_req_builder =
1159            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1160    }
1161    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1162        local_var_req_builder =
1163            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1164    }
1165    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1166        let local_var_key = local_var_apikey.key.clone();
1167        let local_var_value = match local_var_apikey.prefix {
1168            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1169            None => local_var_key,
1170        };
1171        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1172    };
1173    local_var_req_builder =
1174        local_var_req_builder.json(&patched_bulk_writable_ip_address_to_interface_request);
1175
1176    let local_var_req = local_var_req_builder.build()?;
1177    let local_var_resp = local_var_client.execute(local_var_req).await?;
1178
1179    let local_var_status = local_var_resp.status();
1180    let local_var_content = local_var_resp.text().await?;
1181
1182    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1183        serde_json::from_str(&local_var_content).map_err(Error::from)
1184    } else {
1185        let local_var_entity: Option<IpamIpAddressToInterfaceBulkPartialUpdateError> =
1186            serde_json::from_str(&local_var_content).ok();
1187        let local_var_error = ResponseContent {
1188            status: local_var_status,
1189            content: local_var_content,
1190            entity: local_var_entity,
1191        };
1192        Err(Error::ResponseError(local_var_error))
1193    }
1194}
1195
1196/// Update a list of IP Address Assignment objects.
1197pub async fn ipam_ip_address_to_interface_bulk_update(
1198    configuration: &configuration::Configuration,
1199    bulk_writable_ip_address_to_interface_request: Vec<
1200        crate::models::BulkWritableIpAddressToInterfaceRequest,
1201    >,
1202    format: Option<&str>,
1203) -> Result<Vec<crate::models::IpAddressToInterface>, Error<IpamIpAddressToInterfaceBulkUpdateError>>
1204{
1205    let local_var_configuration = configuration;
1206
1207    let local_var_client = &local_var_configuration.client;
1208
1209    let local_var_uri_str = format!(
1210        "{}/ipam/ip-address-to-interface/",
1211        local_var_configuration.base_path
1212    );
1213    let mut local_var_req_builder =
1214        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1215
1216    if let Some(ref local_var_str) = format {
1217        local_var_req_builder =
1218            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1219    }
1220    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1221        local_var_req_builder =
1222            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1223    }
1224    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1225        let local_var_key = local_var_apikey.key.clone();
1226        let local_var_value = match local_var_apikey.prefix {
1227            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1228            None => local_var_key,
1229        };
1230        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1231    };
1232    local_var_req_builder =
1233        local_var_req_builder.json(&bulk_writable_ip_address_to_interface_request);
1234
1235    let local_var_req = local_var_req_builder.build()?;
1236    let local_var_resp = local_var_client.execute(local_var_req).await?;
1237
1238    let local_var_status = local_var_resp.status();
1239    let local_var_content = local_var_resp.text().await?;
1240
1241    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1242        serde_json::from_str(&local_var_content).map_err(Error::from)
1243    } else {
1244        let local_var_entity: Option<IpamIpAddressToInterfaceBulkUpdateError> =
1245            serde_json::from_str(&local_var_content).ok();
1246        let local_var_error = ResponseContent {
1247            status: local_var_status,
1248            content: local_var_content,
1249            entity: local_var_entity,
1250        };
1251        Err(Error::ResponseError(local_var_error))
1252    }
1253}
1254
1255/// Create one or more IP Address Assignment objects.
1256pub async fn ipam_ip_address_to_interface_create(
1257    configuration: &configuration::Configuration,
1258    ip_address_to_interface_request: crate::models::IpAddressToInterfaceRequest,
1259    format: Option<&str>,
1260) -> Result<crate::models::IpAddressToInterface, Error<IpamIpAddressToInterfaceCreateError>> {
1261    let local_var_configuration = configuration;
1262
1263    let local_var_client = &local_var_configuration.client;
1264
1265    let local_var_uri_str = format!(
1266        "{}/ipam/ip-address-to-interface/",
1267        local_var_configuration.base_path
1268    );
1269    let mut local_var_req_builder =
1270        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1271
1272    if let Some(ref local_var_str) = format {
1273        local_var_req_builder =
1274            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1275    }
1276    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1277        local_var_req_builder =
1278            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1279    }
1280    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1281        let local_var_key = local_var_apikey.key.clone();
1282        let local_var_value = match local_var_apikey.prefix {
1283            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1284            None => local_var_key,
1285        };
1286        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1287    };
1288    local_var_req_builder = local_var_req_builder.json(&ip_address_to_interface_request);
1289
1290    let local_var_req = local_var_req_builder.build()?;
1291    let local_var_resp = local_var_client.execute(local_var_req).await?;
1292
1293    let local_var_status = local_var_resp.status();
1294    let local_var_content = local_var_resp.text().await?;
1295
1296    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1297        serde_json::from_str(&local_var_content).map_err(Error::from)
1298    } else {
1299        let local_var_entity: Option<IpamIpAddressToInterfaceCreateError> =
1300            serde_json::from_str(&local_var_content).ok();
1301        let local_var_error = ResponseContent {
1302            status: local_var_status,
1303            content: local_var_content,
1304            entity: local_var_entity,
1305        };
1306        Err(Error::ResponseError(local_var_error))
1307    }
1308}
1309
1310/// Destroy a IP Address Assignment object.
1311pub async fn ipam_ip_address_to_interface_destroy(
1312    configuration: &configuration::Configuration,
1313    id: &str,
1314    format: Option<&str>,
1315) -> Result<(), Error<IpamIpAddressToInterfaceDestroyError>> {
1316    let local_var_configuration = configuration;
1317
1318    let local_var_client = &local_var_configuration.client;
1319
1320    let local_var_uri_str = format!(
1321        "{}/ipam/ip-address-to-interface/{id}/",
1322        local_var_configuration.base_path,
1323        id = crate::apis::urlencode(id)
1324    );
1325    let mut local_var_req_builder =
1326        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1327
1328    if let Some(ref local_var_str) = format {
1329        local_var_req_builder =
1330            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1331    }
1332    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1333        local_var_req_builder =
1334            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1335    }
1336    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1337        let local_var_key = local_var_apikey.key.clone();
1338        let local_var_value = match local_var_apikey.prefix {
1339            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1340            None => local_var_key,
1341        };
1342        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1343    };
1344
1345    let local_var_req = local_var_req_builder.build()?;
1346    let local_var_resp = local_var_client.execute(local_var_req).await?;
1347
1348    let local_var_status = local_var_resp.status();
1349    let local_var_content = local_var_resp.text().await?;
1350
1351    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1352        Ok(())
1353    } else {
1354        let local_var_entity: Option<IpamIpAddressToInterfaceDestroyError> =
1355            serde_json::from_str(&local_var_content).ok();
1356        let local_var_error = ResponseContent {
1357            status: local_var_status,
1358            content: local_var_content,
1359            entity: local_var_entity,
1360        };
1361        Err(Error::ResponseError(local_var_error))
1362    }
1363}
1364
1365/// Retrieve a list of IP Address Assignment objects.
1366pub async fn ipam_ip_address_to_interface_list(
1367    configuration: &configuration::Configuration,
1368    created: Option<Vec<String>>,
1369    format: Option<&str>,
1370    id: Option<Vec<uuid::Uuid>>,
1371    id__n: Option<Vec<uuid::Uuid>>,
1372    interface: Option<Vec<String>>,
1373    interface__isnull: Option<bool>,
1374    interface__n: Option<Vec<String>>,
1375    ip_address: Option<Vec<uuid::Uuid>>,
1376    ip_address__n: Option<Vec<uuid::Uuid>>,
1377    is_default: Option<bool>,
1378    is_destination: Option<bool>,
1379    is_preferred: Option<bool>,
1380    is_primary: Option<bool>,
1381    is_secondary: Option<bool>,
1382    is_source: Option<bool>,
1383    is_standby: Option<bool>,
1384    last_updated: Option<Vec<String>>,
1385    limit: Option<i32>,
1386    offset: Option<i32>,
1387    q: Option<&str>,
1388    sort: Option<&str>,
1389    vm_interface: Option<Vec<String>>,
1390    vm_interface__isnull: Option<bool>,
1391    vm_interface__n: Option<Vec<String>>,
1392    depth: Option<i32>,
1393    exclude_m2m: Option<bool>,
1394) -> Result<
1395    crate::models::PaginatedIpAddressToInterfaceList,
1396    Error<IpamIpAddressToInterfaceListError>,
1397> {
1398    let local_var_configuration = configuration;
1399
1400    let local_var_client = &local_var_configuration.client;
1401
1402    let local_var_uri_str = format!(
1403        "{}/ipam/ip-address-to-interface/",
1404        local_var_configuration.base_path
1405    );
1406    let mut local_var_req_builder =
1407        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1408
1409    if let Some(ref local_var_str) = created {
1410        local_var_req_builder = match "multi" {
1411            "multi" => local_var_req_builder.query(
1412                &local_var_str
1413                    .into_iter()
1414                    .map(|p| ("created".to_owned(), p.to_string()))
1415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1416            ),
1417            _ => local_var_req_builder.query(&[(
1418                "created",
1419                &local_var_str
1420                    .into_iter()
1421                    .map(|p| p.to_string())
1422                    .collect::<Vec<String>>()
1423                    .join(",")
1424                    .to_string(),
1425            )]),
1426        };
1427    }
1428    if let Some(ref local_var_str) = format {
1429        local_var_req_builder =
1430            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1431    }
1432    if let Some(ref local_var_str) = id {
1433        local_var_req_builder = match "multi" {
1434            "multi" => local_var_req_builder.query(
1435                &local_var_str
1436                    .into_iter()
1437                    .map(|p| ("id".to_owned(), p.to_string()))
1438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1439            ),
1440            _ => local_var_req_builder.query(&[(
1441                "id",
1442                &local_var_str
1443                    .into_iter()
1444                    .map(|p| p.to_string())
1445                    .collect::<Vec<String>>()
1446                    .join(",")
1447                    .to_string(),
1448            )]),
1449        };
1450    }
1451    if let Some(ref local_var_str) = id__n {
1452        local_var_req_builder = match "multi" {
1453            "multi" => local_var_req_builder.query(
1454                &local_var_str
1455                    .into_iter()
1456                    .map(|p| ("id__n".to_owned(), p.to_string()))
1457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1458            ),
1459            _ => local_var_req_builder.query(&[(
1460                "id__n",
1461                &local_var_str
1462                    .into_iter()
1463                    .map(|p| p.to_string())
1464                    .collect::<Vec<String>>()
1465                    .join(",")
1466                    .to_string(),
1467            )]),
1468        };
1469    }
1470    if let Some(ref local_var_str) = interface {
1471        local_var_req_builder = match "multi" {
1472            "multi" => local_var_req_builder.query(
1473                &local_var_str
1474                    .into_iter()
1475                    .map(|p| ("interface".to_owned(), p.to_string()))
1476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1477            ),
1478            _ => local_var_req_builder.query(&[(
1479                "interface",
1480                &local_var_str
1481                    .into_iter()
1482                    .map(|p| p.to_string())
1483                    .collect::<Vec<String>>()
1484                    .join(",")
1485                    .to_string(),
1486            )]),
1487        };
1488    }
1489    if let Some(ref local_var_str) = interface__isnull {
1490        local_var_req_builder =
1491            local_var_req_builder.query(&[("interface__isnull", &local_var_str.to_string())]);
1492    }
1493    if let Some(ref local_var_str) = interface__n {
1494        local_var_req_builder = match "multi" {
1495            "multi" => local_var_req_builder.query(
1496                &local_var_str
1497                    .into_iter()
1498                    .map(|p| ("interface__n".to_owned(), p.to_string()))
1499                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1500            ),
1501            _ => local_var_req_builder.query(&[(
1502                "interface__n",
1503                &local_var_str
1504                    .into_iter()
1505                    .map(|p| p.to_string())
1506                    .collect::<Vec<String>>()
1507                    .join(",")
1508                    .to_string(),
1509            )]),
1510        };
1511    }
1512    if let Some(ref local_var_str) = ip_address {
1513        local_var_req_builder = match "multi" {
1514            "multi" => local_var_req_builder.query(
1515                &local_var_str
1516                    .into_iter()
1517                    .map(|p| ("ip_address".to_owned(), p.to_string()))
1518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1519            ),
1520            _ => local_var_req_builder.query(&[(
1521                "ip_address",
1522                &local_var_str
1523                    .into_iter()
1524                    .map(|p| p.to_string())
1525                    .collect::<Vec<String>>()
1526                    .join(",")
1527                    .to_string(),
1528            )]),
1529        };
1530    }
1531    if let Some(ref local_var_str) = ip_address__n {
1532        local_var_req_builder = match "multi" {
1533            "multi" => local_var_req_builder.query(
1534                &local_var_str
1535                    .into_iter()
1536                    .map(|p| ("ip_address__n".to_owned(), p.to_string()))
1537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1538            ),
1539            _ => local_var_req_builder.query(&[(
1540                "ip_address__n",
1541                &local_var_str
1542                    .into_iter()
1543                    .map(|p| p.to_string())
1544                    .collect::<Vec<String>>()
1545                    .join(",")
1546                    .to_string(),
1547            )]),
1548        };
1549    }
1550    if let Some(ref local_var_str) = is_default {
1551        local_var_req_builder =
1552            local_var_req_builder.query(&[("is_default", &local_var_str.to_string())]);
1553    }
1554    if let Some(ref local_var_str) = is_destination {
1555        local_var_req_builder =
1556            local_var_req_builder.query(&[("is_destination", &local_var_str.to_string())]);
1557    }
1558    if let Some(ref local_var_str) = is_preferred {
1559        local_var_req_builder =
1560            local_var_req_builder.query(&[("is_preferred", &local_var_str.to_string())]);
1561    }
1562    if let Some(ref local_var_str) = is_primary {
1563        local_var_req_builder =
1564            local_var_req_builder.query(&[("is_primary", &local_var_str.to_string())]);
1565    }
1566    if let Some(ref local_var_str) = is_secondary {
1567        local_var_req_builder =
1568            local_var_req_builder.query(&[("is_secondary", &local_var_str.to_string())]);
1569    }
1570    if let Some(ref local_var_str) = is_source {
1571        local_var_req_builder =
1572            local_var_req_builder.query(&[("is_source", &local_var_str.to_string())]);
1573    }
1574    if let Some(ref local_var_str) = is_standby {
1575        local_var_req_builder =
1576            local_var_req_builder.query(&[("is_standby", &local_var_str.to_string())]);
1577    }
1578    if let Some(ref local_var_str) = last_updated {
1579        local_var_req_builder = match "multi" {
1580            "multi" => local_var_req_builder.query(
1581                &local_var_str
1582                    .into_iter()
1583                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1585            ),
1586            _ => local_var_req_builder.query(&[(
1587                "last_updated",
1588                &local_var_str
1589                    .into_iter()
1590                    .map(|p| p.to_string())
1591                    .collect::<Vec<String>>()
1592                    .join(",")
1593                    .to_string(),
1594            )]),
1595        };
1596    }
1597    if let Some(ref local_var_str) = limit {
1598        local_var_req_builder =
1599            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1600    }
1601    if let Some(ref local_var_str) = offset {
1602        local_var_req_builder =
1603            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1604    }
1605    if let Some(ref local_var_str) = q {
1606        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1607    }
1608    if let Some(ref local_var_str) = sort {
1609        local_var_req_builder =
1610            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
1611    }
1612    if let Some(ref local_var_str) = vm_interface {
1613        local_var_req_builder = match "multi" {
1614            "multi" => local_var_req_builder.query(
1615                &local_var_str
1616                    .into_iter()
1617                    .map(|p| ("vm_interface".to_owned(), p.to_string()))
1618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1619            ),
1620            _ => local_var_req_builder.query(&[(
1621                "vm_interface",
1622                &local_var_str
1623                    .into_iter()
1624                    .map(|p| p.to_string())
1625                    .collect::<Vec<String>>()
1626                    .join(",")
1627                    .to_string(),
1628            )]),
1629        };
1630    }
1631    if let Some(ref local_var_str) = vm_interface__isnull {
1632        local_var_req_builder =
1633            local_var_req_builder.query(&[("vm_interface__isnull", &local_var_str.to_string())]);
1634    }
1635    if let Some(ref local_var_str) = vm_interface__n {
1636        local_var_req_builder = match "multi" {
1637            "multi" => local_var_req_builder.query(
1638                &local_var_str
1639                    .into_iter()
1640                    .map(|p| ("vm_interface__n".to_owned(), p.to_string()))
1641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1642            ),
1643            _ => local_var_req_builder.query(&[(
1644                "vm_interface__n",
1645                &local_var_str
1646                    .into_iter()
1647                    .map(|p| p.to_string())
1648                    .collect::<Vec<String>>()
1649                    .join(",")
1650                    .to_string(),
1651            )]),
1652        };
1653    }
1654    if let Some(ref local_var_str) = depth {
1655        local_var_req_builder =
1656            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1657    }
1658    if let Some(ref local_var_str) = exclude_m2m {
1659        local_var_req_builder =
1660            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1661    }
1662    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1663        local_var_req_builder =
1664            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1665    }
1666    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1667        let local_var_key = local_var_apikey.key.clone();
1668        let local_var_value = match local_var_apikey.prefix {
1669            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1670            None => local_var_key,
1671        };
1672        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1673    };
1674
1675    let local_var_req = local_var_req_builder.build()?;
1676    let local_var_resp = local_var_client.execute(local_var_req).await?;
1677
1678    let local_var_status = local_var_resp.status();
1679    let local_var_content = local_var_resp.text().await?;
1680
1681    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1682        serde_json::from_str(&local_var_content).map_err(Error::from)
1683    } else {
1684        let local_var_entity: Option<IpamIpAddressToInterfaceListError> =
1685            serde_json::from_str(&local_var_content).ok();
1686        let local_var_error = ResponseContent {
1687            status: local_var_status,
1688            content: local_var_content,
1689            entity: local_var_entity,
1690        };
1691        Err(Error::ResponseError(local_var_error))
1692    }
1693}
1694
1695/// API methods for returning or creating notes on an object.
1696pub async fn ipam_ip_address_to_interface_notes_create(
1697    configuration: &configuration::Configuration,
1698    id: &str,
1699    note_input_request: crate::models::NoteInputRequest,
1700    format: Option<&str>,
1701) -> Result<crate::models::Note, Error<IpamIpAddressToInterfaceNotesCreateError>> {
1702    let local_var_configuration = configuration;
1703
1704    let local_var_client = &local_var_configuration.client;
1705
1706    let local_var_uri_str = format!(
1707        "{}/ipam/ip-address-to-interface/{id}/notes/",
1708        local_var_configuration.base_path,
1709        id = crate::apis::urlencode(id)
1710    );
1711    let mut local_var_req_builder =
1712        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1713
1714    if let Some(ref local_var_str) = format {
1715        local_var_req_builder =
1716            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1717    }
1718    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1719        local_var_req_builder =
1720            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1721    }
1722    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1723        let local_var_key = local_var_apikey.key.clone();
1724        let local_var_value = match local_var_apikey.prefix {
1725            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1726            None => local_var_key,
1727        };
1728        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1729    };
1730    local_var_req_builder = local_var_req_builder.json(&note_input_request);
1731
1732    let local_var_req = local_var_req_builder.build()?;
1733    let local_var_resp = local_var_client.execute(local_var_req).await?;
1734
1735    let local_var_status = local_var_resp.status();
1736    let local_var_content = local_var_resp.text().await?;
1737
1738    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1739        serde_json::from_str(&local_var_content).map_err(Error::from)
1740    } else {
1741        let local_var_entity: Option<IpamIpAddressToInterfaceNotesCreateError> =
1742            serde_json::from_str(&local_var_content).ok();
1743        let local_var_error = ResponseContent {
1744            status: local_var_status,
1745            content: local_var_content,
1746            entity: local_var_entity,
1747        };
1748        Err(Error::ResponseError(local_var_error))
1749    }
1750}
1751
1752/// API methods for returning or creating notes on an object.
1753pub async fn ipam_ip_address_to_interface_notes_list(
1754    configuration: &configuration::Configuration,
1755    id: &str,
1756    format: Option<&str>,
1757    limit: Option<i32>,
1758    offset: Option<i32>,
1759    depth: Option<i32>,
1760    exclude_m2m: Option<bool>,
1761) -> Result<crate::models::PaginatedNoteList, Error<IpamIpAddressToInterfaceNotesListError>> {
1762    let local_var_configuration = configuration;
1763
1764    let local_var_client = &local_var_configuration.client;
1765
1766    let local_var_uri_str = format!(
1767        "{}/ipam/ip-address-to-interface/{id}/notes/",
1768        local_var_configuration.base_path,
1769        id = crate::apis::urlencode(id)
1770    );
1771    let mut local_var_req_builder =
1772        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1773
1774    if let Some(ref local_var_str) = format {
1775        local_var_req_builder =
1776            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1777    }
1778    if let Some(ref local_var_str) = limit {
1779        local_var_req_builder =
1780            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1781    }
1782    if let Some(ref local_var_str) = offset {
1783        local_var_req_builder =
1784            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1785    }
1786    if let Some(ref local_var_str) = depth {
1787        local_var_req_builder =
1788            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1789    }
1790    if let Some(ref local_var_str) = exclude_m2m {
1791        local_var_req_builder =
1792            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1793    }
1794    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1795        local_var_req_builder =
1796            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1797    }
1798    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1799        let local_var_key = local_var_apikey.key.clone();
1800        let local_var_value = match local_var_apikey.prefix {
1801            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1802            None => local_var_key,
1803        };
1804        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1805    };
1806
1807    let local_var_req = local_var_req_builder.build()?;
1808    let local_var_resp = local_var_client.execute(local_var_req).await?;
1809
1810    let local_var_status = local_var_resp.status();
1811    let local_var_content = local_var_resp.text().await?;
1812
1813    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1814        serde_json::from_str(&local_var_content).map_err(Error::from)
1815    } else {
1816        let local_var_entity: Option<IpamIpAddressToInterfaceNotesListError> =
1817            serde_json::from_str(&local_var_content).ok();
1818        let local_var_error = ResponseContent {
1819            status: local_var_status,
1820            content: local_var_content,
1821            entity: local_var_entity,
1822        };
1823        Err(Error::ResponseError(local_var_error))
1824    }
1825}
1826
1827/// Partial update a IP Address Assignment object.
1828pub async fn ipam_ip_address_to_interface_partial_update(
1829    configuration: &configuration::Configuration,
1830    id: &str,
1831    format: Option<&str>,
1832    patched_ip_address_to_interface_request: Option<
1833        crate::models::PatchedIpAddressToInterfaceRequest,
1834    >,
1835) -> Result<crate::models::IpAddressToInterface, Error<IpamIpAddressToInterfacePartialUpdateError>>
1836{
1837    let local_var_configuration = configuration;
1838
1839    let local_var_client = &local_var_configuration.client;
1840
1841    let local_var_uri_str = format!(
1842        "{}/ipam/ip-address-to-interface/{id}/",
1843        local_var_configuration.base_path,
1844        id = crate::apis::urlencode(id)
1845    );
1846    let mut local_var_req_builder =
1847        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1848
1849    if let Some(ref local_var_str) = format {
1850        local_var_req_builder =
1851            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1852    }
1853    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1854        local_var_req_builder =
1855            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1856    }
1857    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1858        let local_var_key = local_var_apikey.key.clone();
1859        let local_var_value = match local_var_apikey.prefix {
1860            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1861            None => local_var_key,
1862        };
1863        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1864    };
1865    local_var_req_builder = local_var_req_builder.json(&patched_ip_address_to_interface_request);
1866
1867    let local_var_req = local_var_req_builder.build()?;
1868    let local_var_resp = local_var_client.execute(local_var_req).await?;
1869
1870    let local_var_status = local_var_resp.status();
1871    let local_var_content = local_var_resp.text().await?;
1872
1873    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1874        serde_json::from_str(&local_var_content).map_err(Error::from)
1875    } else {
1876        let local_var_entity: Option<IpamIpAddressToInterfacePartialUpdateError> =
1877            serde_json::from_str(&local_var_content).ok();
1878        let local_var_error = ResponseContent {
1879            status: local_var_status,
1880            content: local_var_content,
1881            entity: local_var_entity,
1882        };
1883        Err(Error::ResponseError(local_var_error))
1884    }
1885}
1886
1887/// Retrieve a IP Address Assignment object.
1888pub async fn ipam_ip_address_to_interface_retrieve(
1889    configuration: &configuration::Configuration,
1890    id: &str,
1891    format: Option<&str>,
1892    depth: Option<i32>,
1893    exclude_m2m: Option<bool>,
1894) -> Result<crate::models::IpAddressToInterface, Error<IpamIpAddressToInterfaceRetrieveError>> {
1895    let local_var_configuration = configuration;
1896
1897    let local_var_client = &local_var_configuration.client;
1898
1899    let local_var_uri_str = format!(
1900        "{}/ipam/ip-address-to-interface/{id}/",
1901        local_var_configuration.base_path,
1902        id = crate::apis::urlencode(id)
1903    );
1904    let mut local_var_req_builder =
1905        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1906
1907    if let Some(ref local_var_str) = format {
1908        local_var_req_builder =
1909            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1910    }
1911    if let Some(ref local_var_str) = depth {
1912        local_var_req_builder =
1913            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1914    }
1915    if let Some(ref local_var_str) = exclude_m2m {
1916        local_var_req_builder =
1917            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1918    }
1919    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1920        local_var_req_builder =
1921            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1922    }
1923    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1924        let local_var_key = local_var_apikey.key.clone();
1925        let local_var_value = match local_var_apikey.prefix {
1926            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1927            None => local_var_key,
1928        };
1929        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1930    };
1931
1932    let local_var_req = local_var_req_builder.build()?;
1933    let local_var_resp = local_var_client.execute(local_var_req).await?;
1934
1935    let local_var_status = local_var_resp.status();
1936    let local_var_content = local_var_resp.text().await?;
1937
1938    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1939        serde_json::from_str(&local_var_content).map_err(Error::from)
1940    } else {
1941        let local_var_entity: Option<IpamIpAddressToInterfaceRetrieveError> =
1942            serde_json::from_str(&local_var_content).ok();
1943        let local_var_error = ResponseContent {
1944            status: local_var_status,
1945            content: local_var_content,
1946            entity: local_var_entity,
1947        };
1948        Err(Error::ResponseError(local_var_error))
1949    }
1950}
1951
1952/// Update a IP Address Assignment object.
1953pub async fn ipam_ip_address_to_interface_update(
1954    configuration: &configuration::Configuration,
1955    id: &str,
1956    ip_address_to_interface_request: crate::models::IpAddressToInterfaceRequest,
1957    format: Option<&str>,
1958) -> Result<crate::models::IpAddressToInterface, Error<IpamIpAddressToInterfaceUpdateError>> {
1959    let local_var_configuration = configuration;
1960
1961    let local_var_client = &local_var_configuration.client;
1962
1963    let local_var_uri_str = format!(
1964        "{}/ipam/ip-address-to-interface/{id}/",
1965        local_var_configuration.base_path,
1966        id = crate::apis::urlencode(id)
1967    );
1968    let mut local_var_req_builder =
1969        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1970
1971    if let Some(ref local_var_str) = format {
1972        local_var_req_builder =
1973            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1974    }
1975    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1976        local_var_req_builder =
1977            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1978    }
1979    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1980        let local_var_key = local_var_apikey.key.clone();
1981        let local_var_value = match local_var_apikey.prefix {
1982            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1983            None => local_var_key,
1984        };
1985        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1986    };
1987    local_var_req_builder = local_var_req_builder.json(&ip_address_to_interface_request);
1988
1989    let local_var_req = local_var_req_builder.build()?;
1990    let local_var_resp = local_var_client.execute(local_var_req).await?;
1991
1992    let local_var_status = local_var_resp.status();
1993    let local_var_content = local_var_resp.text().await?;
1994
1995    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1996        serde_json::from_str(&local_var_content).map_err(Error::from)
1997    } else {
1998        let local_var_entity: Option<IpamIpAddressToInterfaceUpdateError> =
1999            serde_json::from_str(&local_var_content).ok();
2000        let local_var_error = ResponseContent {
2001            status: local_var_status,
2002            content: local_var_content,
2003            entity: local_var_entity,
2004        };
2005        Err(Error::ResponseError(local_var_error))
2006    }
2007}
2008
2009/// Destroy a list of IP address objects.
2010pub async fn ipam_ip_addresses_bulk_destroy(
2011    configuration: &configuration::Configuration,
2012    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
2013    format: Option<&str>,
2014) -> Result<(), Error<IpamIpAddressesBulkDestroyError>> {
2015    let local_var_configuration = configuration;
2016
2017    let local_var_client = &local_var_configuration.client;
2018
2019    let local_var_uri_str = format!("{}/ipam/ip-addresses/", local_var_configuration.base_path);
2020    let mut local_var_req_builder =
2021        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2022
2023    if let Some(ref local_var_str) = format {
2024        local_var_req_builder =
2025            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2026    }
2027    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2028        local_var_req_builder =
2029            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2030    }
2031    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2032        let local_var_key = local_var_apikey.key.clone();
2033        let local_var_value = match local_var_apikey.prefix {
2034            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2035            None => local_var_key,
2036        };
2037        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2038    };
2039    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
2040
2041    let local_var_req = local_var_req_builder.build()?;
2042    let local_var_resp = local_var_client.execute(local_var_req).await?;
2043
2044    let local_var_status = local_var_resp.status();
2045    let local_var_content = local_var_resp.text().await?;
2046
2047    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2048        Ok(())
2049    } else {
2050        let local_var_entity: Option<IpamIpAddressesBulkDestroyError> =
2051            serde_json::from_str(&local_var_content).ok();
2052        let local_var_error = ResponseContent {
2053            status: local_var_status,
2054            content: local_var_content,
2055            entity: local_var_entity,
2056        };
2057        Err(Error::ResponseError(local_var_error))
2058    }
2059}
2060
2061/// Partial update a list of IP address objects.
2062pub async fn ipam_ip_addresses_bulk_partial_update(
2063    configuration: &configuration::Configuration,
2064    patched_bulk_writable_ip_address_request: Vec<
2065        crate::models::PatchedBulkWritableIpAddressRequest,
2066    >,
2067    format: Option<&str>,
2068) -> Result<Vec<crate::models::IpAddress>, Error<IpamIpAddressesBulkPartialUpdateError>> {
2069    let local_var_configuration = configuration;
2070
2071    let local_var_client = &local_var_configuration.client;
2072
2073    let local_var_uri_str = format!("{}/ipam/ip-addresses/", local_var_configuration.base_path);
2074    let mut local_var_req_builder =
2075        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2076
2077    if let Some(ref local_var_str) = format {
2078        local_var_req_builder =
2079            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2080    }
2081    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2082        local_var_req_builder =
2083            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2084    }
2085    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2086        let local_var_key = local_var_apikey.key.clone();
2087        let local_var_value = match local_var_apikey.prefix {
2088            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2089            None => local_var_key,
2090        };
2091        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2092    };
2093    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_ip_address_request);
2094
2095    let local_var_req = local_var_req_builder.build()?;
2096    let local_var_resp = local_var_client.execute(local_var_req).await?;
2097
2098    let local_var_status = local_var_resp.status();
2099    let local_var_content = local_var_resp.text().await?;
2100
2101    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2102        serde_json::from_str(&local_var_content).map_err(Error::from)
2103    } else {
2104        let local_var_entity: Option<IpamIpAddressesBulkPartialUpdateError> =
2105            serde_json::from_str(&local_var_content).ok();
2106        let local_var_error = ResponseContent {
2107            status: local_var_status,
2108            content: local_var_content,
2109            entity: local_var_entity,
2110        };
2111        Err(Error::ResponseError(local_var_error))
2112    }
2113}
2114
2115/// Update a list of IP address objects.
2116pub async fn ipam_ip_addresses_bulk_update(
2117    configuration: &configuration::Configuration,
2118    bulk_writable_ip_address_request: Vec<crate::models::BulkWritableIpAddressRequest>,
2119    format: Option<&str>,
2120) -> Result<Vec<crate::models::IpAddress>, Error<IpamIpAddressesBulkUpdateError>> {
2121    let local_var_configuration = configuration;
2122
2123    let local_var_client = &local_var_configuration.client;
2124
2125    let local_var_uri_str = format!("{}/ipam/ip-addresses/", local_var_configuration.base_path);
2126    let mut local_var_req_builder =
2127        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2128
2129    if let Some(ref local_var_str) = format {
2130        local_var_req_builder =
2131            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2132    }
2133    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2134        local_var_req_builder =
2135            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2136    }
2137    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2138        let local_var_key = local_var_apikey.key.clone();
2139        let local_var_value = match local_var_apikey.prefix {
2140            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2141            None => local_var_key,
2142        };
2143        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2144    };
2145    local_var_req_builder = local_var_req_builder.json(&bulk_writable_ip_address_request);
2146
2147    let local_var_req = local_var_req_builder.build()?;
2148    let local_var_resp = local_var_client.execute(local_var_req).await?;
2149
2150    let local_var_status = local_var_resp.status();
2151    let local_var_content = local_var_resp.text().await?;
2152
2153    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2154        serde_json::from_str(&local_var_content).map_err(Error::from)
2155    } else {
2156        let local_var_entity: Option<IpamIpAddressesBulkUpdateError> =
2157            serde_json::from_str(&local_var_content).ok();
2158        let local_var_error = ResponseContent {
2159            status: local_var_status,
2160            content: local_var_content,
2161            entity: local_var_entity,
2162        };
2163        Err(Error::ResponseError(local_var_error))
2164    }
2165}
2166
2167/// Create one or more IP address objects.
2168pub async fn ipam_ip_addresses_create(
2169    configuration: &configuration::Configuration,
2170    ip_address_request: crate::models::IpAddressRequest,
2171    format: Option<&str>,
2172) -> Result<crate::models::IpAddress, Error<IpamIpAddressesCreateError>> {
2173    let local_var_configuration = configuration;
2174
2175    let local_var_client = &local_var_configuration.client;
2176
2177    let local_var_uri_str = format!("{}/ipam/ip-addresses/", local_var_configuration.base_path);
2178    let mut local_var_req_builder =
2179        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2180
2181    if let Some(ref local_var_str) = format {
2182        local_var_req_builder =
2183            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2184    }
2185    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2186        local_var_req_builder =
2187            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2188    }
2189    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2190        let local_var_key = local_var_apikey.key.clone();
2191        let local_var_value = match local_var_apikey.prefix {
2192            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2193            None => local_var_key,
2194        };
2195        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2196    };
2197    local_var_req_builder = local_var_req_builder.json(&ip_address_request);
2198
2199    let local_var_req = local_var_req_builder.build()?;
2200    let local_var_resp = local_var_client.execute(local_var_req).await?;
2201
2202    let local_var_status = local_var_resp.status();
2203    let local_var_content = local_var_resp.text().await?;
2204
2205    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2206        serde_json::from_str(&local_var_content).map_err(Error::from)
2207    } else {
2208        let local_var_entity: Option<IpamIpAddressesCreateError> =
2209            serde_json::from_str(&local_var_content).ok();
2210        let local_var_error = ResponseContent {
2211            status: local_var_status,
2212            content: local_var_content,
2213            entity: local_var_entity,
2214        };
2215        Err(Error::ResponseError(local_var_error))
2216    }
2217}
2218
2219/// Destroy a IP address object.
2220pub async fn ipam_ip_addresses_destroy(
2221    configuration: &configuration::Configuration,
2222    id: &str,
2223    format: Option<&str>,
2224) -> Result<(), Error<IpamIpAddressesDestroyError>> {
2225    let local_var_configuration = configuration;
2226
2227    let local_var_client = &local_var_configuration.client;
2228
2229    let local_var_uri_str = format!(
2230        "{}/ipam/ip-addresses/{id}/",
2231        local_var_configuration.base_path,
2232        id = crate::apis::urlencode(id)
2233    );
2234    let mut local_var_req_builder =
2235        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2236
2237    if let Some(ref local_var_str) = format {
2238        local_var_req_builder =
2239            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2240    }
2241    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2242        local_var_req_builder =
2243            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2244    }
2245    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2246        let local_var_key = local_var_apikey.key.clone();
2247        let local_var_value = match local_var_apikey.prefix {
2248            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2249            None => local_var_key,
2250        };
2251        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2252    };
2253
2254    let local_var_req = local_var_req_builder.build()?;
2255    let local_var_resp = local_var_client.execute(local_var_req).await?;
2256
2257    let local_var_status = local_var_resp.status();
2258    let local_var_content = local_var_resp.text().await?;
2259
2260    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2261        Ok(())
2262    } else {
2263        let local_var_entity: Option<IpamIpAddressesDestroyError> =
2264            serde_json::from_str(&local_var_content).ok();
2265        let local_var_error = ResponseContent {
2266            status: local_var_status,
2267            content: local_var_content,
2268            entity: local_var_entity,
2269        };
2270        Err(Error::ResponseError(local_var_error))
2271    }
2272}
2273
2274/// Retrieve a list of IP address objects.
2275pub async fn ipam_ip_addresses_list(
2276    configuration: &configuration::Configuration,
2277    address: Option<Vec<String>>,
2278    contacts: Option<Vec<String>>,
2279    contacts__isnull: Option<bool>,
2280    contacts__n: Option<Vec<String>>,
2281    created: Option<Vec<String>>,
2282    created__gt: Option<Vec<String>>,
2283    created__gte: Option<Vec<String>>,
2284    created__isnull: Option<bool>,
2285    created__lt: Option<Vec<String>>,
2286    created__lte: Option<Vec<String>>,
2287    created__n: Option<Vec<String>>,
2288    description: Option<Vec<String>>,
2289    description__ic: Option<Vec<String>>,
2290    description__ie: Option<Vec<String>>,
2291    description__iew: Option<Vec<String>>,
2292    description__ire: Option<Vec<String>>,
2293    description__isw: Option<Vec<String>>,
2294    description__n: Option<Vec<String>>,
2295    description__nic: Option<Vec<String>>,
2296    description__nie: Option<Vec<String>>,
2297    description__niew: Option<Vec<String>>,
2298    description__nire: Option<Vec<String>>,
2299    description__nisw: Option<Vec<String>>,
2300    description__nre: Option<Vec<String>>,
2301    description__re: Option<Vec<String>>,
2302    device: Option<Vec<String>>,
2303    device_id: Option<Vec<uuid::Uuid>>,
2304    dns_name: Option<Vec<String>>,
2305    dns_name__ic: Option<Vec<String>>,
2306    dns_name__ie: Option<Vec<String>>,
2307    dns_name__iew: Option<Vec<String>>,
2308    dns_name__ire: Option<Vec<String>>,
2309    dns_name__isw: Option<Vec<String>>,
2310    dns_name__n: Option<Vec<String>>,
2311    dns_name__nic: Option<Vec<String>>,
2312    dns_name__nie: Option<Vec<String>>,
2313    dns_name__niew: Option<Vec<String>>,
2314    dns_name__nire: Option<Vec<String>>,
2315    dns_name__nisw: Option<Vec<String>>,
2316    dns_name__nre: Option<Vec<String>>,
2317    dns_name__re: Option<Vec<String>>,
2318    dynamic_groups: Option<Vec<String>>,
2319    dynamic_groups__n: Option<Vec<String>>,
2320    format: Option<&str>,
2321    has_interface_assignments: Option<bool>,
2322    has_nat_inside: Option<bool>,
2323    id: Option<Vec<uuid::Uuid>>,
2324    id__n: Option<Vec<uuid::Uuid>>,
2325    interfaces: Option<Vec<String>>,
2326    interfaces__isnull: Option<bool>,
2327    interfaces__n: Option<Vec<String>>,
2328    ip_version: Option<i32>,
2329    last_updated: Option<Vec<String>>,
2330    last_updated__gt: Option<Vec<String>>,
2331    last_updated__gte: Option<Vec<String>>,
2332    last_updated__isnull: Option<bool>,
2333    last_updated__lt: Option<Vec<String>>,
2334    last_updated__lte: Option<Vec<String>>,
2335    last_updated__n: Option<Vec<String>>,
2336    limit: Option<i32>,
2337    mask_length: Option<Vec<i32>>,
2338    mask_length__gt: Option<Vec<i32>>,
2339    mask_length__gte: Option<Vec<i32>>,
2340    mask_length__lt: Option<Vec<i32>>,
2341    mask_length__lte: Option<Vec<i32>>,
2342    mask_length__n: Option<Vec<i32>>,
2343    namespace: Option<Vec<String>>,
2344    namespace__n: Option<Vec<String>>,
2345    nat_inside: Option<Vec<uuid::Uuid>>,
2346    nat_inside__isnull: Option<bool>,
2347    nat_inside__n: Option<Vec<uuid::Uuid>>,
2348    offset: Option<i32>,
2349    parent: Option<Vec<uuid::Uuid>>,
2350    parent__isnull: Option<bool>,
2351    parent__n: Option<Vec<uuid::Uuid>>,
2352    prefix: Option<Vec<String>>,
2353    prefix_exact: Option<Vec<String>>,
2354    present_in_vrf: Option<&str>,
2355    present_in_vrf_id: Option<&str>,
2356    q: Option<&str>,
2357    role: Option<Vec<String>>,
2358    role__isnull: Option<bool>,
2359    role__n: Option<Vec<String>>,
2360    services: Option<Vec<String>>,
2361    services__isnull: Option<bool>,
2362    services__n: Option<Vec<String>>,
2363    sort: Option<&str>,
2364    status: Option<Vec<String>>,
2365    status__n: Option<Vec<String>>,
2366    tags: Option<Vec<String>>,
2367    tags__isnull: Option<bool>,
2368    tags__n: Option<Vec<String>>,
2369    teams: Option<Vec<String>>,
2370    teams__isnull: Option<bool>,
2371    teams__n: Option<Vec<String>>,
2372    tenant: Option<Vec<String>>,
2373    tenant__isnull: Option<bool>,
2374    tenant__n: Option<Vec<String>>,
2375    tenant_group: Option<Vec<String>>,
2376    tenant_group__isnull: Option<bool>,
2377    tenant_group__n: Option<Vec<String>>,
2378    tenant_id: Option<Vec<uuid::Uuid>>,
2379    tenant_id__isnull: Option<bool>,
2380    tenant_id__n: Option<Vec<uuid::Uuid>>,
2381    r#type: Option<Vec<String>>,
2382    type__ic: Option<Vec<String>>,
2383    type__ie: Option<Vec<String>>,
2384    type__iew: Option<Vec<String>>,
2385    type__ire: Option<Vec<String>>,
2386    type__isw: Option<Vec<String>>,
2387    type__n: Option<Vec<String>>,
2388    type__nic: Option<Vec<String>>,
2389    type__nie: Option<Vec<String>>,
2390    type__niew: Option<Vec<String>>,
2391    type__nire: Option<Vec<String>>,
2392    type__nisw: Option<Vec<String>>,
2393    type__nre: Option<Vec<String>>,
2394    type__re: Option<Vec<String>>,
2395    virtual_machine: Option<Vec<String>>,
2396    virtual_machine_id: Option<Vec<uuid::Uuid>>,
2397    vm_interfaces: Option<Vec<String>>,
2398    vm_interfaces__isnull: Option<bool>,
2399    vm_interfaces__n: Option<Vec<String>>,
2400    vrfs: Option<Vec<String>>,
2401    vrfs__isnull: Option<bool>,
2402    vrfs__n: Option<Vec<String>>,
2403    depth: Option<i32>,
2404    exclude_m2m: Option<bool>,
2405) -> Result<crate::models::PaginatedIpAddressList, Error<IpamIpAddressesListError>> {
2406    let local_var_configuration = configuration;
2407
2408    let local_var_client = &local_var_configuration.client;
2409
2410    let local_var_uri_str = format!("{}/ipam/ip-addresses/", local_var_configuration.base_path);
2411    let mut local_var_req_builder =
2412        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2413
2414    if let Some(ref local_var_str) = address {
2415        local_var_req_builder = match "multi" {
2416            "multi" => local_var_req_builder.query(
2417                &local_var_str
2418                    .into_iter()
2419                    .map(|p| ("address".to_owned(), p.to_string()))
2420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2421            ),
2422            _ => local_var_req_builder.query(&[(
2423                "address",
2424                &local_var_str
2425                    .into_iter()
2426                    .map(|p| p.to_string())
2427                    .collect::<Vec<String>>()
2428                    .join(",")
2429                    .to_string(),
2430            )]),
2431        };
2432    }
2433    if let Some(ref local_var_str) = contacts {
2434        local_var_req_builder = match "multi" {
2435            "multi" => local_var_req_builder.query(
2436                &local_var_str
2437                    .into_iter()
2438                    .map(|p| ("contacts".to_owned(), p.to_string()))
2439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2440            ),
2441            _ => local_var_req_builder.query(&[(
2442                "contacts",
2443                &local_var_str
2444                    .into_iter()
2445                    .map(|p| p.to_string())
2446                    .collect::<Vec<String>>()
2447                    .join(",")
2448                    .to_string(),
2449            )]),
2450        };
2451    }
2452    if let Some(ref local_var_str) = contacts__isnull {
2453        local_var_req_builder =
2454            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
2455    }
2456    if let Some(ref local_var_str) = contacts__n {
2457        local_var_req_builder = match "multi" {
2458            "multi" => local_var_req_builder.query(
2459                &local_var_str
2460                    .into_iter()
2461                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
2462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2463            ),
2464            _ => local_var_req_builder.query(&[(
2465                "contacts__n",
2466                &local_var_str
2467                    .into_iter()
2468                    .map(|p| p.to_string())
2469                    .collect::<Vec<String>>()
2470                    .join(",")
2471                    .to_string(),
2472            )]),
2473        };
2474    }
2475    if let Some(ref local_var_str) = created {
2476        local_var_req_builder = match "multi" {
2477            "multi" => local_var_req_builder.query(
2478                &local_var_str
2479                    .into_iter()
2480                    .map(|p| ("created".to_owned(), p.to_string()))
2481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2482            ),
2483            _ => local_var_req_builder.query(&[(
2484                "created",
2485                &local_var_str
2486                    .into_iter()
2487                    .map(|p| p.to_string())
2488                    .collect::<Vec<String>>()
2489                    .join(",")
2490                    .to_string(),
2491            )]),
2492        };
2493    }
2494    if let Some(ref local_var_str) = created__gt {
2495        local_var_req_builder = match "multi" {
2496            "multi" => local_var_req_builder.query(
2497                &local_var_str
2498                    .into_iter()
2499                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2501            ),
2502            _ => local_var_req_builder.query(&[(
2503                "created__gt",
2504                &local_var_str
2505                    .into_iter()
2506                    .map(|p| p.to_string())
2507                    .collect::<Vec<String>>()
2508                    .join(",")
2509                    .to_string(),
2510            )]),
2511        };
2512    }
2513    if let Some(ref local_var_str) = created__gte {
2514        local_var_req_builder = match "multi" {
2515            "multi" => local_var_req_builder.query(
2516                &local_var_str
2517                    .into_iter()
2518                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2520            ),
2521            _ => local_var_req_builder.query(&[(
2522                "created__gte",
2523                &local_var_str
2524                    .into_iter()
2525                    .map(|p| p.to_string())
2526                    .collect::<Vec<String>>()
2527                    .join(",")
2528                    .to_string(),
2529            )]),
2530        };
2531    }
2532    if let Some(ref local_var_str) = created__isnull {
2533        local_var_req_builder =
2534            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
2535    }
2536    if let Some(ref local_var_str) = created__lt {
2537        local_var_req_builder = match "multi" {
2538            "multi" => local_var_req_builder.query(
2539                &local_var_str
2540                    .into_iter()
2541                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2543            ),
2544            _ => local_var_req_builder.query(&[(
2545                "created__lt",
2546                &local_var_str
2547                    .into_iter()
2548                    .map(|p| p.to_string())
2549                    .collect::<Vec<String>>()
2550                    .join(",")
2551                    .to_string(),
2552            )]),
2553        };
2554    }
2555    if let Some(ref local_var_str) = created__lte {
2556        local_var_req_builder = match "multi" {
2557            "multi" => local_var_req_builder.query(
2558                &local_var_str
2559                    .into_iter()
2560                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2562            ),
2563            _ => local_var_req_builder.query(&[(
2564                "created__lte",
2565                &local_var_str
2566                    .into_iter()
2567                    .map(|p| p.to_string())
2568                    .collect::<Vec<String>>()
2569                    .join(",")
2570                    .to_string(),
2571            )]),
2572        };
2573    }
2574    if let Some(ref local_var_str) = created__n {
2575        local_var_req_builder = match "multi" {
2576            "multi" => local_var_req_builder.query(
2577                &local_var_str
2578                    .into_iter()
2579                    .map(|p| ("created__n".to_owned(), p.to_string()))
2580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2581            ),
2582            _ => local_var_req_builder.query(&[(
2583                "created__n",
2584                &local_var_str
2585                    .into_iter()
2586                    .map(|p| p.to_string())
2587                    .collect::<Vec<String>>()
2588                    .join(",")
2589                    .to_string(),
2590            )]),
2591        };
2592    }
2593    if let Some(ref local_var_str) = description {
2594        local_var_req_builder = match "multi" {
2595            "multi" => local_var_req_builder.query(
2596                &local_var_str
2597                    .into_iter()
2598                    .map(|p| ("description".to_owned(), p.to_string()))
2599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2600            ),
2601            _ => local_var_req_builder.query(&[(
2602                "description",
2603                &local_var_str
2604                    .into_iter()
2605                    .map(|p| p.to_string())
2606                    .collect::<Vec<String>>()
2607                    .join(",")
2608                    .to_string(),
2609            )]),
2610        };
2611    }
2612    if let Some(ref local_var_str) = description__ic {
2613        local_var_req_builder = match "multi" {
2614            "multi" => local_var_req_builder.query(
2615                &local_var_str
2616                    .into_iter()
2617                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2619            ),
2620            _ => local_var_req_builder.query(&[(
2621                "description__ic",
2622                &local_var_str
2623                    .into_iter()
2624                    .map(|p| p.to_string())
2625                    .collect::<Vec<String>>()
2626                    .join(",")
2627                    .to_string(),
2628            )]),
2629        };
2630    }
2631    if let Some(ref local_var_str) = description__ie {
2632        local_var_req_builder = match "multi" {
2633            "multi" => local_var_req_builder.query(
2634                &local_var_str
2635                    .into_iter()
2636                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2638            ),
2639            _ => local_var_req_builder.query(&[(
2640                "description__ie",
2641                &local_var_str
2642                    .into_iter()
2643                    .map(|p| p.to_string())
2644                    .collect::<Vec<String>>()
2645                    .join(",")
2646                    .to_string(),
2647            )]),
2648        };
2649    }
2650    if let Some(ref local_var_str) = description__iew {
2651        local_var_req_builder = match "multi" {
2652            "multi" => local_var_req_builder.query(
2653                &local_var_str
2654                    .into_iter()
2655                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2657            ),
2658            _ => local_var_req_builder.query(&[(
2659                "description__iew",
2660                &local_var_str
2661                    .into_iter()
2662                    .map(|p| p.to_string())
2663                    .collect::<Vec<String>>()
2664                    .join(",")
2665                    .to_string(),
2666            )]),
2667        };
2668    }
2669    if let Some(ref local_var_str) = description__ire {
2670        local_var_req_builder = match "multi" {
2671            "multi" => local_var_req_builder.query(
2672                &local_var_str
2673                    .into_iter()
2674                    .map(|p| ("description__ire".to_owned(), p.to_string()))
2675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2676            ),
2677            _ => local_var_req_builder.query(&[(
2678                "description__ire",
2679                &local_var_str
2680                    .into_iter()
2681                    .map(|p| p.to_string())
2682                    .collect::<Vec<String>>()
2683                    .join(",")
2684                    .to_string(),
2685            )]),
2686        };
2687    }
2688    if let Some(ref local_var_str) = description__isw {
2689        local_var_req_builder = match "multi" {
2690            "multi" => local_var_req_builder.query(
2691                &local_var_str
2692                    .into_iter()
2693                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2695            ),
2696            _ => local_var_req_builder.query(&[(
2697                "description__isw",
2698                &local_var_str
2699                    .into_iter()
2700                    .map(|p| p.to_string())
2701                    .collect::<Vec<String>>()
2702                    .join(",")
2703                    .to_string(),
2704            )]),
2705        };
2706    }
2707    if let Some(ref local_var_str) = description__n {
2708        local_var_req_builder = match "multi" {
2709            "multi" => local_var_req_builder.query(
2710                &local_var_str
2711                    .into_iter()
2712                    .map(|p| ("description__n".to_owned(), p.to_string()))
2713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2714            ),
2715            _ => local_var_req_builder.query(&[(
2716                "description__n",
2717                &local_var_str
2718                    .into_iter()
2719                    .map(|p| p.to_string())
2720                    .collect::<Vec<String>>()
2721                    .join(",")
2722                    .to_string(),
2723            )]),
2724        };
2725    }
2726    if let Some(ref local_var_str) = description__nic {
2727        local_var_req_builder = match "multi" {
2728            "multi" => local_var_req_builder.query(
2729                &local_var_str
2730                    .into_iter()
2731                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2733            ),
2734            _ => local_var_req_builder.query(&[(
2735                "description__nic",
2736                &local_var_str
2737                    .into_iter()
2738                    .map(|p| p.to_string())
2739                    .collect::<Vec<String>>()
2740                    .join(",")
2741                    .to_string(),
2742            )]),
2743        };
2744    }
2745    if let Some(ref local_var_str) = description__nie {
2746        local_var_req_builder = match "multi" {
2747            "multi" => local_var_req_builder.query(
2748                &local_var_str
2749                    .into_iter()
2750                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2752            ),
2753            _ => local_var_req_builder.query(&[(
2754                "description__nie",
2755                &local_var_str
2756                    .into_iter()
2757                    .map(|p| p.to_string())
2758                    .collect::<Vec<String>>()
2759                    .join(",")
2760                    .to_string(),
2761            )]),
2762        };
2763    }
2764    if let Some(ref local_var_str) = description__niew {
2765        local_var_req_builder = match "multi" {
2766            "multi" => local_var_req_builder.query(
2767                &local_var_str
2768                    .into_iter()
2769                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2771            ),
2772            _ => local_var_req_builder.query(&[(
2773                "description__niew",
2774                &local_var_str
2775                    .into_iter()
2776                    .map(|p| p.to_string())
2777                    .collect::<Vec<String>>()
2778                    .join(",")
2779                    .to_string(),
2780            )]),
2781        };
2782    }
2783    if let Some(ref local_var_str) = description__nire {
2784        local_var_req_builder = match "multi" {
2785            "multi" => local_var_req_builder.query(
2786                &local_var_str
2787                    .into_iter()
2788                    .map(|p| ("description__nire".to_owned(), p.to_string()))
2789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2790            ),
2791            _ => local_var_req_builder.query(&[(
2792                "description__nire",
2793                &local_var_str
2794                    .into_iter()
2795                    .map(|p| p.to_string())
2796                    .collect::<Vec<String>>()
2797                    .join(",")
2798                    .to_string(),
2799            )]),
2800        };
2801    }
2802    if let Some(ref local_var_str) = description__nisw {
2803        local_var_req_builder = match "multi" {
2804            "multi" => local_var_req_builder.query(
2805                &local_var_str
2806                    .into_iter()
2807                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2809            ),
2810            _ => local_var_req_builder.query(&[(
2811                "description__nisw",
2812                &local_var_str
2813                    .into_iter()
2814                    .map(|p| p.to_string())
2815                    .collect::<Vec<String>>()
2816                    .join(",")
2817                    .to_string(),
2818            )]),
2819        };
2820    }
2821    if let Some(ref local_var_str) = description__nre {
2822        local_var_req_builder = match "multi" {
2823            "multi" => local_var_req_builder.query(
2824                &local_var_str
2825                    .into_iter()
2826                    .map(|p| ("description__nre".to_owned(), p.to_string()))
2827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2828            ),
2829            _ => local_var_req_builder.query(&[(
2830                "description__nre",
2831                &local_var_str
2832                    .into_iter()
2833                    .map(|p| p.to_string())
2834                    .collect::<Vec<String>>()
2835                    .join(",")
2836                    .to_string(),
2837            )]),
2838        };
2839    }
2840    if let Some(ref local_var_str) = description__re {
2841        local_var_req_builder = match "multi" {
2842            "multi" => local_var_req_builder.query(
2843                &local_var_str
2844                    .into_iter()
2845                    .map(|p| ("description__re".to_owned(), p.to_string()))
2846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2847            ),
2848            _ => local_var_req_builder.query(&[(
2849                "description__re",
2850                &local_var_str
2851                    .into_iter()
2852                    .map(|p| p.to_string())
2853                    .collect::<Vec<String>>()
2854                    .join(",")
2855                    .to_string(),
2856            )]),
2857        };
2858    }
2859    if let Some(ref local_var_str) = device {
2860        local_var_req_builder = match "multi" {
2861            "multi" => local_var_req_builder.query(
2862                &local_var_str
2863                    .into_iter()
2864                    .map(|p| ("device".to_owned(), p.to_string()))
2865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2866            ),
2867            _ => local_var_req_builder.query(&[(
2868                "device",
2869                &local_var_str
2870                    .into_iter()
2871                    .map(|p| p.to_string())
2872                    .collect::<Vec<String>>()
2873                    .join(",")
2874                    .to_string(),
2875            )]),
2876        };
2877    }
2878    if let Some(ref local_var_str) = device_id {
2879        local_var_req_builder = match "multi" {
2880            "multi" => local_var_req_builder.query(
2881                &local_var_str
2882                    .into_iter()
2883                    .map(|p| ("device_id".to_owned(), p.to_string()))
2884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2885            ),
2886            _ => local_var_req_builder.query(&[(
2887                "device_id",
2888                &local_var_str
2889                    .into_iter()
2890                    .map(|p| p.to_string())
2891                    .collect::<Vec<String>>()
2892                    .join(",")
2893                    .to_string(),
2894            )]),
2895        };
2896    }
2897    if let Some(ref local_var_str) = dns_name {
2898        local_var_req_builder = match "multi" {
2899            "multi" => local_var_req_builder.query(
2900                &local_var_str
2901                    .into_iter()
2902                    .map(|p| ("dns_name".to_owned(), p.to_string()))
2903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2904            ),
2905            _ => local_var_req_builder.query(&[(
2906                "dns_name",
2907                &local_var_str
2908                    .into_iter()
2909                    .map(|p| p.to_string())
2910                    .collect::<Vec<String>>()
2911                    .join(",")
2912                    .to_string(),
2913            )]),
2914        };
2915    }
2916    if let Some(ref local_var_str) = dns_name__ic {
2917        local_var_req_builder = match "multi" {
2918            "multi" => local_var_req_builder.query(
2919                &local_var_str
2920                    .into_iter()
2921                    .map(|p| ("dns_name__ic".to_owned(), p.to_string()))
2922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2923            ),
2924            _ => local_var_req_builder.query(&[(
2925                "dns_name__ic",
2926                &local_var_str
2927                    .into_iter()
2928                    .map(|p| p.to_string())
2929                    .collect::<Vec<String>>()
2930                    .join(",")
2931                    .to_string(),
2932            )]),
2933        };
2934    }
2935    if let Some(ref local_var_str) = dns_name__ie {
2936        local_var_req_builder = match "multi" {
2937            "multi" => local_var_req_builder.query(
2938                &local_var_str
2939                    .into_iter()
2940                    .map(|p| ("dns_name__ie".to_owned(), p.to_string()))
2941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2942            ),
2943            _ => local_var_req_builder.query(&[(
2944                "dns_name__ie",
2945                &local_var_str
2946                    .into_iter()
2947                    .map(|p| p.to_string())
2948                    .collect::<Vec<String>>()
2949                    .join(",")
2950                    .to_string(),
2951            )]),
2952        };
2953    }
2954    if let Some(ref local_var_str) = dns_name__iew {
2955        local_var_req_builder = match "multi" {
2956            "multi" => local_var_req_builder.query(
2957                &local_var_str
2958                    .into_iter()
2959                    .map(|p| ("dns_name__iew".to_owned(), p.to_string()))
2960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2961            ),
2962            _ => local_var_req_builder.query(&[(
2963                "dns_name__iew",
2964                &local_var_str
2965                    .into_iter()
2966                    .map(|p| p.to_string())
2967                    .collect::<Vec<String>>()
2968                    .join(",")
2969                    .to_string(),
2970            )]),
2971        };
2972    }
2973    if let Some(ref local_var_str) = dns_name__ire {
2974        local_var_req_builder = match "multi" {
2975            "multi" => local_var_req_builder.query(
2976                &local_var_str
2977                    .into_iter()
2978                    .map(|p| ("dns_name__ire".to_owned(), p.to_string()))
2979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2980            ),
2981            _ => local_var_req_builder.query(&[(
2982                "dns_name__ire",
2983                &local_var_str
2984                    .into_iter()
2985                    .map(|p| p.to_string())
2986                    .collect::<Vec<String>>()
2987                    .join(",")
2988                    .to_string(),
2989            )]),
2990        };
2991    }
2992    if let Some(ref local_var_str) = dns_name__isw {
2993        local_var_req_builder = match "multi" {
2994            "multi" => local_var_req_builder.query(
2995                &local_var_str
2996                    .into_iter()
2997                    .map(|p| ("dns_name__isw".to_owned(), p.to_string()))
2998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2999            ),
3000            _ => local_var_req_builder.query(&[(
3001                "dns_name__isw",
3002                &local_var_str
3003                    .into_iter()
3004                    .map(|p| p.to_string())
3005                    .collect::<Vec<String>>()
3006                    .join(",")
3007                    .to_string(),
3008            )]),
3009        };
3010    }
3011    if let Some(ref local_var_str) = dns_name__n {
3012        local_var_req_builder = match "multi" {
3013            "multi" => local_var_req_builder.query(
3014                &local_var_str
3015                    .into_iter()
3016                    .map(|p| ("dns_name__n".to_owned(), p.to_string()))
3017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3018            ),
3019            _ => local_var_req_builder.query(&[(
3020                "dns_name__n",
3021                &local_var_str
3022                    .into_iter()
3023                    .map(|p| p.to_string())
3024                    .collect::<Vec<String>>()
3025                    .join(",")
3026                    .to_string(),
3027            )]),
3028        };
3029    }
3030    if let Some(ref local_var_str) = dns_name__nic {
3031        local_var_req_builder = match "multi" {
3032            "multi" => local_var_req_builder.query(
3033                &local_var_str
3034                    .into_iter()
3035                    .map(|p| ("dns_name__nic".to_owned(), p.to_string()))
3036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3037            ),
3038            _ => local_var_req_builder.query(&[(
3039                "dns_name__nic",
3040                &local_var_str
3041                    .into_iter()
3042                    .map(|p| p.to_string())
3043                    .collect::<Vec<String>>()
3044                    .join(",")
3045                    .to_string(),
3046            )]),
3047        };
3048    }
3049    if let Some(ref local_var_str) = dns_name__nie {
3050        local_var_req_builder = match "multi" {
3051            "multi" => local_var_req_builder.query(
3052                &local_var_str
3053                    .into_iter()
3054                    .map(|p| ("dns_name__nie".to_owned(), p.to_string()))
3055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3056            ),
3057            _ => local_var_req_builder.query(&[(
3058                "dns_name__nie",
3059                &local_var_str
3060                    .into_iter()
3061                    .map(|p| p.to_string())
3062                    .collect::<Vec<String>>()
3063                    .join(",")
3064                    .to_string(),
3065            )]),
3066        };
3067    }
3068    if let Some(ref local_var_str) = dns_name__niew {
3069        local_var_req_builder = match "multi" {
3070            "multi" => local_var_req_builder.query(
3071                &local_var_str
3072                    .into_iter()
3073                    .map(|p| ("dns_name__niew".to_owned(), p.to_string()))
3074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3075            ),
3076            _ => local_var_req_builder.query(&[(
3077                "dns_name__niew",
3078                &local_var_str
3079                    .into_iter()
3080                    .map(|p| p.to_string())
3081                    .collect::<Vec<String>>()
3082                    .join(",")
3083                    .to_string(),
3084            )]),
3085        };
3086    }
3087    if let Some(ref local_var_str) = dns_name__nire {
3088        local_var_req_builder = match "multi" {
3089            "multi" => local_var_req_builder.query(
3090                &local_var_str
3091                    .into_iter()
3092                    .map(|p| ("dns_name__nire".to_owned(), p.to_string()))
3093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3094            ),
3095            _ => local_var_req_builder.query(&[(
3096                "dns_name__nire",
3097                &local_var_str
3098                    .into_iter()
3099                    .map(|p| p.to_string())
3100                    .collect::<Vec<String>>()
3101                    .join(",")
3102                    .to_string(),
3103            )]),
3104        };
3105    }
3106    if let Some(ref local_var_str) = dns_name__nisw {
3107        local_var_req_builder = match "multi" {
3108            "multi" => local_var_req_builder.query(
3109                &local_var_str
3110                    .into_iter()
3111                    .map(|p| ("dns_name__nisw".to_owned(), p.to_string()))
3112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3113            ),
3114            _ => local_var_req_builder.query(&[(
3115                "dns_name__nisw",
3116                &local_var_str
3117                    .into_iter()
3118                    .map(|p| p.to_string())
3119                    .collect::<Vec<String>>()
3120                    .join(",")
3121                    .to_string(),
3122            )]),
3123        };
3124    }
3125    if let Some(ref local_var_str) = dns_name__nre {
3126        local_var_req_builder = match "multi" {
3127            "multi" => local_var_req_builder.query(
3128                &local_var_str
3129                    .into_iter()
3130                    .map(|p| ("dns_name__nre".to_owned(), p.to_string()))
3131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3132            ),
3133            _ => local_var_req_builder.query(&[(
3134                "dns_name__nre",
3135                &local_var_str
3136                    .into_iter()
3137                    .map(|p| p.to_string())
3138                    .collect::<Vec<String>>()
3139                    .join(",")
3140                    .to_string(),
3141            )]),
3142        };
3143    }
3144    if let Some(ref local_var_str) = dns_name__re {
3145        local_var_req_builder = match "multi" {
3146            "multi" => local_var_req_builder.query(
3147                &local_var_str
3148                    .into_iter()
3149                    .map(|p| ("dns_name__re".to_owned(), p.to_string()))
3150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3151            ),
3152            _ => local_var_req_builder.query(&[(
3153                "dns_name__re",
3154                &local_var_str
3155                    .into_iter()
3156                    .map(|p| p.to_string())
3157                    .collect::<Vec<String>>()
3158                    .join(",")
3159                    .to_string(),
3160            )]),
3161        };
3162    }
3163    if let Some(ref local_var_str) = dynamic_groups {
3164        local_var_req_builder = match "multi" {
3165            "multi" => local_var_req_builder.query(
3166                &local_var_str
3167                    .into_iter()
3168                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
3169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3170            ),
3171            _ => local_var_req_builder.query(&[(
3172                "dynamic_groups",
3173                &local_var_str
3174                    .into_iter()
3175                    .map(|p| p.to_string())
3176                    .collect::<Vec<String>>()
3177                    .join(",")
3178                    .to_string(),
3179            )]),
3180        };
3181    }
3182    if let Some(ref local_var_str) = dynamic_groups__n {
3183        local_var_req_builder = match "multi" {
3184            "multi" => local_var_req_builder.query(
3185                &local_var_str
3186                    .into_iter()
3187                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
3188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3189            ),
3190            _ => local_var_req_builder.query(&[(
3191                "dynamic_groups__n",
3192                &local_var_str
3193                    .into_iter()
3194                    .map(|p| p.to_string())
3195                    .collect::<Vec<String>>()
3196                    .join(",")
3197                    .to_string(),
3198            )]),
3199        };
3200    }
3201    if let Some(ref local_var_str) = format {
3202        local_var_req_builder =
3203            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3204    }
3205    if let Some(ref local_var_str) = has_interface_assignments {
3206        local_var_req_builder = local_var_req_builder
3207            .query(&[("has_interface_assignments", &local_var_str.to_string())]);
3208    }
3209    if let Some(ref local_var_str) = has_nat_inside {
3210        local_var_req_builder =
3211            local_var_req_builder.query(&[("has_nat_inside", &local_var_str.to_string())]);
3212    }
3213    if let Some(ref local_var_str) = id {
3214        local_var_req_builder = match "multi" {
3215            "multi" => local_var_req_builder.query(
3216                &local_var_str
3217                    .into_iter()
3218                    .map(|p| ("id".to_owned(), p.to_string()))
3219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3220            ),
3221            _ => local_var_req_builder.query(&[(
3222                "id",
3223                &local_var_str
3224                    .into_iter()
3225                    .map(|p| p.to_string())
3226                    .collect::<Vec<String>>()
3227                    .join(",")
3228                    .to_string(),
3229            )]),
3230        };
3231    }
3232    if let Some(ref local_var_str) = id__n {
3233        local_var_req_builder = match "multi" {
3234            "multi" => local_var_req_builder.query(
3235                &local_var_str
3236                    .into_iter()
3237                    .map(|p| ("id__n".to_owned(), p.to_string()))
3238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3239            ),
3240            _ => local_var_req_builder.query(&[(
3241                "id__n",
3242                &local_var_str
3243                    .into_iter()
3244                    .map(|p| p.to_string())
3245                    .collect::<Vec<String>>()
3246                    .join(",")
3247                    .to_string(),
3248            )]),
3249        };
3250    }
3251    if let Some(ref local_var_str) = interfaces {
3252        local_var_req_builder = match "multi" {
3253            "multi" => local_var_req_builder.query(
3254                &local_var_str
3255                    .into_iter()
3256                    .map(|p| ("interfaces".to_owned(), p.to_string()))
3257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3258            ),
3259            _ => local_var_req_builder.query(&[(
3260                "interfaces",
3261                &local_var_str
3262                    .into_iter()
3263                    .map(|p| p.to_string())
3264                    .collect::<Vec<String>>()
3265                    .join(",")
3266                    .to_string(),
3267            )]),
3268        };
3269    }
3270    if let Some(ref local_var_str) = interfaces__isnull {
3271        local_var_req_builder =
3272            local_var_req_builder.query(&[("interfaces__isnull", &local_var_str.to_string())]);
3273    }
3274    if let Some(ref local_var_str) = interfaces__n {
3275        local_var_req_builder = match "multi" {
3276            "multi" => local_var_req_builder.query(
3277                &local_var_str
3278                    .into_iter()
3279                    .map(|p| ("interfaces__n".to_owned(), p.to_string()))
3280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3281            ),
3282            _ => local_var_req_builder.query(&[(
3283                "interfaces__n",
3284                &local_var_str
3285                    .into_iter()
3286                    .map(|p| p.to_string())
3287                    .collect::<Vec<String>>()
3288                    .join(",")
3289                    .to_string(),
3290            )]),
3291        };
3292    }
3293    if let Some(ref local_var_str) = ip_version {
3294        local_var_req_builder =
3295            local_var_req_builder.query(&[("ip_version", &local_var_str.to_string())]);
3296    }
3297    if let Some(ref local_var_str) = last_updated {
3298        local_var_req_builder = match "multi" {
3299            "multi" => local_var_req_builder.query(
3300                &local_var_str
3301                    .into_iter()
3302                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3304            ),
3305            _ => local_var_req_builder.query(&[(
3306                "last_updated",
3307                &local_var_str
3308                    .into_iter()
3309                    .map(|p| p.to_string())
3310                    .collect::<Vec<String>>()
3311                    .join(",")
3312                    .to_string(),
3313            )]),
3314        };
3315    }
3316    if let Some(ref local_var_str) = last_updated__gt {
3317        local_var_req_builder = match "multi" {
3318            "multi" => local_var_req_builder.query(
3319                &local_var_str
3320                    .into_iter()
3321                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3323            ),
3324            _ => local_var_req_builder.query(&[(
3325                "last_updated__gt",
3326                &local_var_str
3327                    .into_iter()
3328                    .map(|p| p.to_string())
3329                    .collect::<Vec<String>>()
3330                    .join(",")
3331                    .to_string(),
3332            )]),
3333        };
3334    }
3335    if let Some(ref local_var_str) = last_updated__gte {
3336        local_var_req_builder = match "multi" {
3337            "multi" => local_var_req_builder.query(
3338                &local_var_str
3339                    .into_iter()
3340                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3342            ),
3343            _ => local_var_req_builder.query(&[(
3344                "last_updated__gte",
3345                &local_var_str
3346                    .into_iter()
3347                    .map(|p| p.to_string())
3348                    .collect::<Vec<String>>()
3349                    .join(",")
3350                    .to_string(),
3351            )]),
3352        };
3353    }
3354    if let Some(ref local_var_str) = last_updated__isnull {
3355        local_var_req_builder =
3356            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
3357    }
3358    if let Some(ref local_var_str) = last_updated__lt {
3359        local_var_req_builder = match "multi" {
3360            "multi" => local_var_req_builder.query(
3361                &local_var_str
3362                    .into_iter()
3363                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3365            ),
3366            _ => local_var_req_builder.query(&[(
3367                "last_updated__lt",
3368                &local_var_str
3369                    .into_iter()
3370                    .map(|p| p.to_string())
3371                    .collect::<Vec<String>>()
3372                    .join(",")
3373                    .to_string(),
3374            )]),
3375        };
3376    }
3377    if let Some(ref local_var_str) = last_updated__lte {
3378        local_var_req_builder = match "multi" {
3379            "multi" => local_var_req_builder.query(
3380                &local_var_str
3381                    .into_iter()
3382                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3384            ),
3385            _ => local_var_req_builder.query(&[(
3386                "last_updated__lte",
3387                &local_var_str
3388                    .into_iter()
3389                    .map(|p| p.to_string())
3390                    .collect::<Vec<String>>()
3391                    .join(",")
3392                    .to_string(),
3393            )]),
3394        };
3395    }
3396    if let Some(ref local_var_str) = last_updated__n {
3397        local_var_req_builder = match "multi" {
3398            "multi" => local_var_req_builder.query(
3399                &local_var_str
3400                    .into_iter()
3401                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3403            ),
3404            _ => local_var_req_builder.query(&[(
3405                "last_updated__n",
3406                &local_var_str
3407                    .into_iter()
3408                    .map(|p| p.to_string())
3409                    .collect::<Vec<String>>()
3410                    .join(",")
3411                    .to_string(),
3412            )]),
3413        };
3414    }
3415    if let Some(ref local_var_str) = limit {
3416        local_var_req_builder =
3417            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3418    }
3419    if let Some(ref local_var_str) = mask_length {
3420        local_var_req_builder = match "multi" {
3421            "multi" => local_var_req_builder.query(
3422                &local_var_str
3423                    .into_iter()
3424                    .map(|p| ("mask_length".to_owned(), p.to_string()))
3425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3426            ),
3427            _ => local_var_req_builder.query(&[(
3428                "mask_length",
3429                &local_var_str
3430                    .into_iter()
3431                    .map(|p| p.to_string())
3432                    .collect::<Vec<String>>()
3433                    .join(",")
3434                    .to_string(),
3435            )]),
3436        };
3437    }
3438    if let Some(ref local_var_str) = mask_length__gt {
3439        local_var_req_builder = match "multi" {
3440            "multi" => local_var_req_builder.query(
3441                &local_var_str
3442                    .into_iter()
3443                    .map(|p| ("mask_length__gt".to_owned(), p.to_string()))
3444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3445            ),
3446            _ => local_var_req_builder.query(&[(
3447                "mask_length__gt",
3448                &local_var_str
3449                    .into_iter()
3450                    .map(|p| p.to_string())
3451                    .collect::<Vec<String>>()
3452                    .join(",")
3453                    .to_string(),
3454            )]),
3455        };
3456    }
3457    if let Some(ref local_var_str) = mask_length__gte {
3458        local_var_req_builder = match "multi" {
3459            "multi" => local_var_req_builder.query(
3460                &local_var_str
3461                    .into_iter()
3462                    .map(|p| ("mask_length__gte".to_owned(), p.to_string()))
3463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3464            ),
3465            _ => local_var_req_builder.query(&[(
3466                "mask_length__gte",
3467                &local_var_str
3468                    .into_iter()
3469                    .map(|p| p.to_string())
3470                    .collect::<Vec<String>>()
3471                    .join(",")
3472                    .to_string(),
3473            )]),
3474        };
3475    }
3476    if let Some(ref local_var_str) = mask_length__lt {
3477        local_var_req_builder = match "multi" {
3478            "multi" => local_var_req_builder.query(
3479                &local_var_str
3480                    .into_iter()
3481                    .map(|p| ("mask_length__lt".to_owned(), p.to_string()))
3482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3483            ),
3484            _ => local_var_req_builder.query(&[(
3485                "mask_length__lt",
3486                &local_var_str
3487                    .into_iter()
3488                    .map(|p| p.to_string())
3489                    .collect::<Vec<String>>()
3490                    .join(",")
3491                    .to_string(),
3492            )]),
3493        };
3494    }
3495    if let Some(ref local_var_str) = mask_length__lte {
3496        local_var_req_builder = match "multi" {
3497            "multi" => local_var_req_builder.query(
3498                &local_var_str
3499                    .into_iter()
3500                    .map(|p| ("mask_length__lte".to_owned(), p.to_string()))
3501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3502            ),
3503            _ => local_var_req_builder.query(&[(
3504                "mask_length__lte",
3505                &local_var_str
3506                    .into_iter()
3507                    .map(|p| p.to_string())
3508                    .collect::<Vec<String>>()
3509                    .join(",")
3510                    .to_string(),
3511            )]),
3512        };
3513    }
3514    if let Some(ref local_var_str) = mask_length__n {
3515        local_var_req_builder = match "multi" {
3516            "multi" => local_var_req_builder.query(
3517                &local_var_str
3518                    .into_iter()
3519                    .map(|p| ("mask_length__n".to_owned(), p.to_string()))
3520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3521            ),
3522            _ => local_var_req_builder.query(&[(
3523                "mask_length__n",
3524                &local_var_str
3525                    .into_iter()
3526                    .map(|p| p.to_string())
3527                    .collect::<Vec<String>>()
3528                    .join(",")
3529                    .to_string(),
3530            )]),
3531        };
3532    }
3533    if let Some(ref local_var_str) = namespace {
3534        local_var_req_builder = match "multi" {
3535            "multi" => local_var_req_builder.query(
3536                &local_var_str
3537                    .into_iter()
3538                    .map(|p| ("namespace".to_owned(), p.to_string()))
3539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3540            ),
3541            _ => local_var_req_builder.query(&[(
3542                "namespace",
3543                &local_var_str
3544                    .into_iter()
3545                    .map(|p| p.to_string())
3546                    .collect::<Vec<String>>()
3547                    .join(",")
3548                    .to_string(),
3549            )]),
3550        };
3551    }
3552    if let Some(ref local_var_str) = namespace__n {
3553        local_var_req_builder = match "multi" {
3554            "multi" => local_var_req_builder.query(
3555                &local_var_str
3556                    .into_iter()
3557                    .map(|p| ("namespace__n".to_owned(), p.to_string()))
3558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3559            ),
3560            _ => local_var_req_builder.query(&[(
3561                "namespace__n",
3562                &local_var_str
3563                    .into_iter()
3564                    .map(|p| p.to_string())
3565                    .collect::<Vec<String>>()
3566                    .join(",")
3567                    .to_string(),
3568            )]),
3569        };
3570    }
3571    if let Some(ref local_var_str) = nat_inside {
3572        local_var_req_builder = match "multi" {
3573            "multi" => local_var_req_builder.query(
3574                &local_var_str
3575                    .into_iter()
3576                    .map(|p| ("nat_inside".to_owned(), p.to_string()))
3577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3578            ),
3579            _ => local_var_req_builder.query(&[(
3580                "nat_inside",
3581                &local_var_str
3582                    .into_iter()
3583                    .map(|p| p.to_string())
3584                    .collect::<Vec<String>>()
3585                    .join(",")
3586                    .to_string(),
3587            )]),
3588        };
3589    }
3590    if let Some(ref local_var_str) = nat_inside__isnull {
3591        local_var_req_builder =
3592            local_var_req_builder.query(&[("nat_inside__isnull", &local_var_str.to_string())]);
3593    }
3594    if let Some(ref local_var_str) = nat_inside__n {
3595        local_var_req_builder = match "multi" {
3596            "multi" => local_var_req_builder.query(
3597                &local_var_str
3598                    .into_iter()
3599                    .map(|p| ("nat_inside__n".to_owned(), p.to_string()))
3600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3601            ),
3602            _ => local_var_req_builder.query(&[(
3603                "nat_inside__n",
3604                &local_var_str
3605                    .into_iter()
3606                    .map(|p| p.to_string())
3607                    .collect::<Vec<String>>()
3608                    .join(",")
3609                    .to_string(),
3610            )]),
3611        };
3612    }
3613    if let Some(ref local_var_str) = offset {
3614        local_var_req_builder =
3615            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3616    }
3617    if let Some(ref local_var_str) = parent {
3618        local_var_req_builder = match "multi" {
3619            "multi" => local_var_req_builder.query(
3620                &local_var_str
3621                    .into_iter()
3622                    .map(|p| ("parent".to_owned(), p.to_string()))
3623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3624            ),
3625            _ => local_var_req_builder.query(&[(
3626                "parent",
3627                &local_var_str
3628                    .into_iter()
3629                    .map(|p| p.to_string())
3630                    .collect::<Vec<String>>()
3631                    .join(",")
3632                    .to_string(),
3633            )]),
3634        };
3635    }
3636    if let Some(ref local_var_str) = parent__isnull {
3637        local_var_req_builder =
3638            local_var_req_builder.query(&[("parent__isnull", &local_var_str.to_string())]);
3639    }
3640    if let Some(ref local_var_str) = parent__n {
3641        local_var_req_builder = match "multi" {
3642            "multi" => local_var_req_builder.query(
3643                &local_var_str
3644                    .into_iter()
3645                    .map(|p| ("parent__n".to_owned(), p.to_string()))
3646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3647            ),
3648            _ => local_var_req_builder.query(&[(
3649                "parent__n",
3650                &local_var_str
3651                    .into_iter()
3652                    .map(|p| p.to_string())
3653                    .collect::<Vec<String>>()
3654                    .join(",")
3655                    .to_string(),
3656            )]),
3657        };
3658    }
3659    if let Some(ref local_var_str) = prefix {
3660        local_var_req_builder = match "multi" {
3661            "multi" => local_var_req_builder.query(
3662                &local_var_str
3663                    .into_iter()
3664                    .map(|p| ("prefix".to_owned(), p.to_string()))
3665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3666            ),
3667            _ => local_var_req_builder.query(&[(
3668                "prefix",
3669                &local_var_str
3670                    .into_iter()
3671                    .map(|p| p.to_string())
3672                    .collect::<Vec<String>>()
3673                    .join(",")
3674                    .to_string(),
3675            )]),
3676        };
3677    }
3678    if let Some(ref local_var_str) = prefix_exact {
3679        local_var_req_builder = match "multi" {
3680            "multi" => local_var_req_builder.query(
3681                &local_var_str
3682                    .into_iter()
3683                    .map(|p| ("prefix_exact".to_owned(), p.to_string()))
3684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3685            ),
3686            _ => local_var_req_builder.query(&[(
3687                "prefix_exact",
3688                &local_var_str
3689                    .into_iter()
3690                    .map(|p| p.to_string())
3691                    .collect::<Vec<String>>()
3692                    .join(",")
3693                    .to_string(),
3694            )]),
3695        };
3696    }
3697    if let Some(ref local_var_str) = present_in_vrf {
3698        local_var_req_builder =
3699            local_var_req_builder.query(&[("present_in_vrf", &local_var_str.to_string())]);
3700    }
3701    if let Some(ref local_var_str) = present_in_vrf_id {
3702        local_var_req_builder =
3703            local_var_req_builder.query(&[("present_in_vrf_id", &local_var_str.to_string())]);
3704    }
3705    if let Some(ref local_var_str) = q {
3706        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3707    }
3708    if let Some(ref local_var_str) = role {
3709        local_var_req_builder = match "multi" {
3710            "multi" => local_var_req_builder.query(
3711                &local_var_str
3712                    .into_iter()
3713                    .map(|p| ("role".to_owned(), p.to_string()))
3714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3715            ),
3716            _ => local_var_req_builder.query(&[(
3717                "role",
3718                &local_var_str
3719                    .into_iter()
3720                    .map(|p| p.to_string())
3721                    .collect::<Vec<String>>()
3722                    .join(",")
3723                    .to_string(),
3724            )]),
3725        };
3726    }
3727    if let Some(ref local_var_str) = role__isnull {
3728        local_var_req_builder =
3729            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
3730    }
3731    if let Some(ref local_var_str) = role__n {
3732        local_var_req_builder = match "multi" {
3733            "multi" => local_var_req_builder.query(
3734                &local_var_str
3735                    .into_iter()
3736                    .map(|p| ("role__n".to_owned(), p.to_string()))
3737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3738            ),
3739            _ => local_var_req_builder.query(&[(
3740                "role__n",
3741                &local_var_str
3742                    .into_iter()
3743                    .map(|p| p.to_string())
3744                    .collect::<Vec<String>>()
3745                    .join(",")
3746                    .to_string(),
3747            )]),
3748        };
3749    }
3750    if let Some(ref local_var_str) = services {
3751        local_var_req_builder = match "multi" {
3752            "multi" => local_var_req_builder.query(
3753                &local_var_str
3754                    .into_iter()
3755                    .map(|p| ("services".to_owned(), p.to_string()))
3756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3757            ),
3758            _ => local_var_req_builder.query(&[(
3759                "services",
3760                &local_var_str
3761                    .into_iter()
3762                    .map(|p| p.to_string())
3763                    .collect::<Vec<String>>()
3764                    .join(",")
3765                    .to_string(),
3766            )]),
3767        };
3768    }
3769    if let Some(ref local_var_str) = services__isnull {
3770        local_var_req_builder =
3771            local_var_req_builder.query(&[("services__isnull", &local_var_str.to_string())]);
3772    }
3773    if let Some(ref local_var_str) = services__n {
3774        local_var_req_builder = match "multi" {
3775            "multi" => local_var_req_builder.query(
3776                &local_var_str
3777                    .into_iter()
3778                    .map(|p| ("services__n".to_owned(), p.to_string()))
3779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3780            ),
3781            _ => local_var_req_builder.query(&[(
3782                "services__n",
3783                &local_var_str
3784                    .into_iter()
3785                    .map(|p| p.to_string())
3786                    .collect::<Vec<String>>()
3787                    .join(",")
3788                    .to_string(),
3789            )]),
3790        };
3791    }
3792    if let Some(ref local_var_str) = sort {
3793        local_var_req_builder =
3794            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
3795    }
3796    if let Some(ref local_var_str) = status {
3797        local_var_req_builder = match "multi" {
3798            "multi" => local_var_req_builder.query(
3799                &local_var_str
3800                    .into_iter()
3801                    .map(|p| ("status".to_owned(), p.to_string()))
3802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3803            ),
3804            _ => local_var_req_builder.query(&[(
3805                "status",
3806                &local_var_str
3807                    .into_iter()
3808                    .map(|p| p.to_string())
3809                    .collect::<Vec<String>>()
3810                    .join(",")
3811                    .to_string(),
3812            )]),
3813        };
3814    }
3815    if let Some(ref local_var_str) = status__n {
3816        local_var_req_builder = match "multi" {
3817            "multi" => local_var_req_builder.query(
3818                &local_var_str
3819                    .into_iter()
3820                    .map(|p| ("status__n".to_owned(), p.to_string()))
3821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3822            ),
3823            _ => local_var_req_builder.query(&[(
3824                "status__n",
3825                &local_var_str
3826                    .into_iter()
3827                    .map(|p| p.to_string())
3828                    .collect::<Vec<String>>()
3829                    .join(",")
3830                    .to_string(),
3831            )]),
3832        };
3833    }
3834    if let Some(ref local_var_str) = tags {
3835        local_var_req_builder = match "multi" {
3836            "multi" => local_var_req_builder.query(
3837                &local_var_str
3838                    .into_iter()
3839                    .map(|p| ("tags".to_owned(), p.to_string()))
3840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3841            ),
3842            _ => local_var_req_builder.query(&[(
3843                "tags",
3844                &local_var_str
3845                    .into_iter()
3846                    .map(|p| p.to_string())
3847                    .collect::<Vec<String>>()
3848                    .join(",")
3849                    .to_string(),
3850            )]),
3851        };
3852    }
3853    if let Some(ref local_var_str) = tags__isnull {
3854        local_var_req_builder =
3855            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
3856    }
3857    if let Some(ref local_var_str) = tags__n {
3858        local_var_req_builder = match "multi" {
3859            "multi" => local_var_req_builder.query(
3860                &local_var_str
3861                    .into_iter()
3862                    .map(|p| ("tags__n".to_owned(), p.to_string()))
3863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3864            ),
3865            _ => local_var_req_builder.query(&[(
3866                "tags__n",
3867                &local_var_str
3868                    .into_iter()
3869                    .map(|p| p.to_string())
3870                    .collect::<Vec<String>>()
3871                    .join(",")
3872                    .to_string(),
3873            )]),
3874        };
3875    }
3876    if let Some(ref local_var_str) = teams {
3877        local_var_req_builder = match "multi" {
3878            "multi" => local_var_req_builder.query(
3879                &local_var_str
3880                    .into_iter()
3881                    .map(|p| ("teams".to_owned(), p.to_string()))
3882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3883            ),
3884            _ => local_var_req_builder.query(&[(
3885                "teams",
3886                &local_var_str
3887                    .into_iter()
3888                    .map(|p| p.to_string())
3889                    .collect::<Vec<String>>()
3890                    .join(",")
3891                    .to_string(),
3892            )]),
3893        };
3894    }
3895    if let Some(ref local_var_str) = teams__isnull {
3896        local_var_req_builder =
3897            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
3898    }
3899    if let Some(ref local_var_str) = teams__n {
3900        local_var_req_builder = match "multi" {
3901            "multi" => local_var_req_builder.query(
3902                &local_var_str
3903                    .into_iter()
3904                    .map(|p| ("teams__n".to_owned(), p.to_string()))
3905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3906            ),
3907            _ => local_var_req_builder.query(&[(
3908                "teams__n",
3909                &local_var_str
3910                    .into_iter()
3911                    .map(|p| p.to_string())
3912                    .collect::<Vec<String>>()
3913                    .join(",")
3914                    .to_string(),
3915            )]),
3916        };
3917    }
3918    if let Some(ref local_var_str) = tenant {
3919        local_var_req_builder = match "multi" {
3920            "multi" => local_var_req_builder.query(
3921                &local_var_str
3922                    .into_iter()
3923                    .map(|p| ("tenant".to_owned(), p.to_string()))
3924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3925            ),
3926            _ => local_var_req_builder.query(&[(
3927                "tenant",
3928                &local_var_str
3929                    .into_iter()
3930                    .map(|p| p.to_string())
3931                    .collect::<Vec<String>>()
3932                    .join(",")
3933                    .to_string(),
3934            )]),
3935        };
3936    }
3937    if let Some(ref local_var_str) = tenant__isnull {
3938        local_var_req_builder =
3939            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
3940    }
3941    if let Some(ref local_var_str) = tenant__n {
3942        local_var_req_builder = match "multi" {
3943            "multi" => local_var_req_builder.query(
3944                &local_var_str
3945                    .into_iter()
3946                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
3947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3948            ),
3949            _ => local_var_req_builder.query(&[(
3950                "tenant__n",
3951                &local_var_str
3952                    .into_iter()
3953                    .map(|p| p.to_string())
3954                    .collect::<Vec<String>>()
3955                    .join(",")
3956                    .to_string(),
3957            )]),
3958        };
3959    }
3960    if let Some(ref local_var_str) = tenant_group {
3961        local_var_req_builder = match "multi" {
3962            "multi" => local_var_req_builder.query(
3963                &local_var_str
3964                    .into_iter()
3965                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
3966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3967            ),
3968            _ => local_var_req_builder.query(&[(
3969                "tenant_group",
3970                &local_var_str
3971                    .into_iter()
3972                    .map(|p| p.to_string())
3973                    .collect::<Vec<String>>()
3974                    .join(",")
3975                    .to_string(),
3976            )]),
3977        };
3978    }
3979    if let Some(ref local_var_str) = tenant_group__isnull {
3980        local_var_req_builder =
3981            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
3982    }
3983    if let Some(ref local_var_str) = tenant_group__n {
3984        local_var_req_builder = match "multi" {
3985            "multi" => local_var_req_builder.query(
3986                &local_var_str
3987                    .into_iter()
3988                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
3989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3990            ),
3991            _ => local_var_req_builder.query(&[(
3992                "tenant_group__n",
3993                &local_var_str
3994                    .into_iter()
3995                    .map(|p| p.to_string())
3996                    .collect::<Vec<String>>()
3997                    .join(",")
3998                    .to_string(),
3999            )]),
4000        };
4001    }
4002    if let Some(ref local_var_str) = tenant_id {
4003        local_var_req_builder = match "multi" {
4004            "multi" => local_var_req_builder.query(
4005                &local_var_str
4006                    .into_iter()
4007                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
4008                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4009            ),
4010            _ => local_var_req_builder.query(&[(
4011                "tenant_id",
4012                &local_var_str
4013                    .into_iter()
4014                    .map(|p| p.to_string())
4015                    .collect::<Vec<String>>()
4016                    .join(",")
4017                    .to_string(),
4018            )]),
4019        };
4020    }
4021    if let Some(ref local_var_str) = tenant_id__isnull {
4022        local_var_req_builder =
4023            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
4024    }
4025    if let Some(ref local_var_str) = tenant_id__n {
4026        local_var_req_builder = match "multi" {
4027            "multi" => local_var_req_builder.query(
4028                &local_var_str
4029                    .into_iter()
4030                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
4031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4032            ),
4033            _ => local_var_req_builder.query(&[(
4034                "tenant_id__n",
4035                &local_var_str
4036                    .into_iter()
4037                    .map(|p| p.to_string())
4038                    .collect::<Vec<String>>()
4039                    .join(",")
4040                    .to_string(),
4041            )]),
4042        };
4043    }
4044    if let Some(ref local_var_str) = r#type {
4045        local_var_req_builder = match "multi" {
4046            "multi" => local_var_req_builder.query(
4047                &local_var_str
4048                    .into_iter()
4049                    .map(|p| ("type".to_owned(), p.to_string()))
4050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4051            ),
4052            _ => local_var_req_builder.query(&[(
4053                "type",
4054                &local_var_str
4055                    .into_iter()
4056                    .map(|p| p.to_string())
4057                    .collect::<Vec<String>>()
4058                    .join(",")
4059                    .to_string(),
4060            )]),
4061        };
4062    }
4063    if let Some(ref local_var_str) = type__ic {
4064        local_var_req_builder = match "multi" {
4065            "multi" => local_var_req_builder.query(
4066                &local_var_str
4067                    .into_iter()
4068                    .map(|p| ("type__ic".to_owned(), p.to_string()))
4069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4070            ),
4071            _ => local_var_req_builder.query(&[(
4072                "type__ic",
4073                &local_var_str
4074                    .into_iter()
4075                    .map(|p| p.to_string())
4076                    .collect::<Vec<String>>()
4077                    .join(",")
4078                    .to_string(),
4079            )]),
4080        };
4081    }
4082    if let Some(ref local_var_str) = type__ie {
4083        local_var_req_builder = match "multi" {
4084            "multi" => local_var_req_builder.query(
4085                &local_var_str
4086                    .into_iter()
4087                    .map(|p| ("type__ie".to_owned(), p.to_string()))
4088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4089            ),
4090            _ => local_var_req_builder.query(&[(
4091                "type__ie",
4092                &local_var_str
4093                    .into_iter()
4094                    .map(|p| p.to_string())
4095                    .collect::<Vec<String>>()
4096                    .join(",")
4097                    .to_string(),
4098            )]),
4099        };
4100    }
4101    if let Some(ref local_var_str) = type__iew {
4102        local_var_req_builder = match "multi" {
4103            "multi" => local_var_req_builder.query(
4104                &local_var_str
4105                    .into_iter()
4106                    .map(|p| ("type__iew".to_owned(), p.to_string()))
4107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4108            ),
4109            _ => local_var_req_builder.query(&[(
4110                "type__iew",
4111                &local_var_str
4112                    .into_iter()
4113                    .map(|p| p.to_string())
4114                    .collect::<Vec<String>>()
4115                    .join(",")
4116                    .to_string(),
4117            )]),
4118        };
4119    }
4120    if let Some(ref local_var_str) = type__ire {
4121        local_var_req_builder = match "multi" {
4122            "multi" => local_var_req_builder.query(
4123                &local_var_str
4124                    .into_iter()
4125                    .map(|p| ("type__ire".to_owned(), p.to_string()))
4126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4127            ),
4128            _ => local_var_req_builder.query(&[(
4129                "type__ire",
4130                &local_var_str
4131                    .into_iter()
4132                    .map(|p| p.to_string())
4133                    .collect::<Vec<String>>()
4134                    .join(",")
4135                    .to_string(),
4136            )]),
4137        };
4138    }
4139    if let Some(ref local_var_str) = type__isw {
4140        local_var_req_builder = match "multi" {
4141            "multi" => local_var_req_builder.query(
4142                &local_var_str
4143                    .into_iter()
4144                    .map(|p| ("type__isw".to_owned(), p.to_string()))
4145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4146            ),
4147            _ => local_var_req_builder.query(&[(
4148                "type__isw",
4149                &local_var_str
4150                    .into_iter()
4151                    .map(|p| p.to_string())
4152                    .collect::<Vec<String>>()
4153                    .join(",")
4154                    .to_string(),
4155            )]),
4156        };
4157    }
4158    if let Some(ref local_var_str) = type__n {
4159        local_var_req_builder = match "multi" {
4160            "multi" => local_var_req_builder.query(
4161                &local_var_str
4162                    .into_iter()
4163                    .map(|p| ("type__n".to_owned(), p.to_string()))
4164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4165            ),
4166            _ => local_var_req_builder.query(&[(
4167                "type__n",
4168                &local_var_str
4169                    .into_iter()
4170                    .map(|p| p.to_string())
4171                    .collect::<Vec<String>>()
4172                    .join(",")
4173                    .to_string(),
4174            )]),
4175        };
4176    }
4177    if let Some(ref local_var_str) = type__nic {
4178        local_var_req_builder = match "multi" {
4179            "multi" => local_var_req_builder.query(
4180                &local_var_str
4181                    .into_iter()
4182                    .map(|p| ("type__nic".to_owned(), p.to_string()))
4183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4184            ),
4185            _ => local_var_req_builder.query(&[(
4186                "type__nic",
4187                &local_var_str
4188                    .into_iter()
4189                    .map(|p| p.to_string())
4190                    .collect::<Vec<String>>()
4191                    .join(",")
4192                    .to_string(),
4193            )]),
4194        };
4195    }
4196    if let Some(ref local_var_str) = type__nie {
4197        local_var_req_builder = match "multi" {
4198            "multi" => local_var_req_builder.query(
4199                &local_var_str
4200                    .into_iter()
4201                    .map(|p| ("type__nie".to_owned(), p.to_string()))
4202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4203            ),
4204            _ => local_var_req_builder.query(&[(
4205                "type__nie",
4206                &local_var_str
4207                    .into_iter()
4208                    .map(|p| p.to_string())
4209                    .collect::<Vec<String>>()
4210                    .join(",")
4211                    .to_string(),
4212            )]),
4213        };
4214    }
4215    if let Some(ref local_var_str) = type__niew {
4216        local_var_req_builder = match "multi" {
4217            "multi" => local_var_req_builder.query(
4218                &local_var_str
4219                    .into_iter()
4220                    .map(|p| ("type__niew".to_owned(), p.to_string()))
4221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4222            ),
4223            _ => local_var_req_builder.query(&[(
4224                "type__niew",
4225                &local_var_str
4226                    .into_iter()
4227                    .map(|p| p.to_string())
4228                    .collect::<Vec<String>>()
4229                    .join(",")
4230                    .to_string(),
4231            )]),
4232        };
4233    }
4234    if let Some(ref local_var_str) = type__nire {
4235        local_var_req_builder = match "multi" {
4236            "multi" => local_var_req_builder.query(
4237                &local_var_str
4238                    .into_iter()
4239                    .map(|p| ("type__nire".to_owned(), p.to_string()))
4240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4241            ),
4242            _ => local_var_req_builder.query(&[(
4243                "type__nire",
4244                &local_var_str
4245                    .into_iter()
4246                    .map(|p| p.to_string())
4247                    .collect::<Vec<String>>()
4248                    .join(",")
4249                    .to_string(),
4250            )]),
4251        };
4252    }
4253    if let Some(ref local_var_str) = type__nisw {
4254        local_var_req_builder = match "multi" {
4255            "multi" => local_var_req_builder.query(
4256                &local_var_str
4257                    .into_iter()
4258                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
4259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4260            ),
4261            _ => local_var_req_builder.query(&[(
4262                "type__nisw",
4263                &local_var_str
4264                    .into_iter()
4265                    .map(|p| p.to_string())
4266                    .collect::<Vec<String>>()
4267                    .join(",")
4268                    .to_string(),
4269            )]),
4270        };
4271    }
4272    if let Some(ref local_var_str) = type__nre {
4273        local_var_req_builder = match "multi" {
4274            "multi" => local_var_req_builder.query(
4275                &local_var_str
4276                    .into_iter()
4277                    .map(|p| ("type__nre".to_owned(), p.to_string()))
4278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4279            ),
4280            _ => local_var_req_builder.query(&[(
4281                "type__nre",
4282                &local_var_str
4283                    .into_iter()
4284                    .map(|p| p.to_string())
4285                    .collect::<Vec<String>>()
4286                    .join(",")
4287                    .to_string(),
4288            )]),
4289        };
4290    }
4291    if let Some(ref local_var_str) = type__re {
4292        local_var_req_builder = match "multi" {
4293            "multi" => local_var_req_builder.query(
4294                &local_var_str
4295                    .into_iter()
4296                    .map(|p| ("type__re".to_owned(), p.to_string()))
4297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4298            ),
4299            _ => local_var_req_builder.query(&[(
4300                "type__re",
4301                &local_var_str
4302                    .into_iter()
4303                    .map(|p| p.to_string())
4304                    .collect::<Vec<String>>()
4305                    .join(",")
4306                    .to_string(),
4307            )]),
4308        };
4309    }
4310    if let Some(ref local_var_str) = virtual_machine {
4311        local_var_req_builder = match "multi" {
4312            "multi" => local_var_req_builder.query(
4313                &local_var_str
4314                    .into_iter()
4315                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
4316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4317            ),
4318            _ => local_var_req_builder.query(&[(
4319                "virtual_machine",
4320                &local_var_str
4321                    .into_iter()
4322                    .map(|p| p.to_string())
4323                    .collect::<Vec<String>>()
4324                    .join(",")
4325                    .to_string(),
4326            )]),
4327        };
4328    }
4329    if let Some(ref local_var_str) = virtual_machine_id {
4330        local_var_req_builder = match "multi" {
4331            "multi" => local_var_req_builder.query(
4332                &local_var_str
4333                    .into_iter()
4334                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
4335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4336            ),
4337            _ => local_var_req_builder.query(&[(
4338                "virtual_machine_id",
4339                &local_var_str
4340                    .into_iter()
4341                    .map(|p| p.to_string())
4342                    .collect::<Vec<String>>()
4343                    .join(",")
4344                    .to_string(),
4345            )]),
4346        };
4347    }
4348    if let Some(ref local_var_str) = vm_interfaces {
4349        local_var_req_builder = match "multi" {
4350            "multi" => local_var_req_builder.query(
4351                &local_var_str
4352                    .into_iter()
4353                    .map(|p| ("vm_interfaces".to_owned(), p.to_string()))
4354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4355            ),
4356            _ => local_var_req_builder.query(&[(
4357                "vm_interfaces",
4358                &local_var_str
4359                    .into_iter()
4360                    .map(|p| p.to_string())
4361                    .collect::<Vec<String>>()
4362                    .join(",")
4363                    .to_string(),
4364            )]),
4365        };
4366    }
4367    if let Some(ref local_var_str) = vm_interfaces__isnull {
4368        local_var_req_builder =
4369            local_var_req_builder.query(&[("vm_interfaces__isnull", &local_var_str.to_string())]);
4370    }
4371    if let Some(ref local_var_str) = vm_interfaces__n {
4372        local_var_req_builder = match "multi" {
4373            "multi" => local_var_req_builder.query(
4374                &local_var_str
4375                    .into_iter()
4376                    .map(|p| ("vm_interfaces__n".to_owned(), p.to_string()))
4377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4378            ),
4379            _ => local_var_req_builder.query(&[(
4380                "vm_interfaces__n",
4381                &local_var_str
4382                    .into_iter()
4383                    .map(|p| p.to_string())
4384                    .collect::<Vec<String>>()
4385                    .join(",")
4386                    .to_string(),
4387            )]),
4388        };
4389    }
4390    if let Some(ref local_var_str) = vrfs {
4391        local_var_req_builder = match "multi" {
4392            "multi" => local_var_req_builder.query(
4393                &local_var_str
4394                    .into_iter()
4395                    .map(|p| ("vrfs".to_owned(), p.to_string()))
4396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4397            ),
4398            _ => local_var_req_builder.query(&[(
4399                "vrfs",
4400                &local_var_str
4401                    .into_iter()
4402                    .map(|p| p.to_string())
4403                    .collect::<Vec<String>>()
4404                    .join(",")
4405                    .to_string(),
4406            )]),
4407        };
4408    }
4409    if let Some(ref local_var_str) = vrfs__isnull {
4410        local_var_req_builder =
4411            local_var_req_builder.query(&[("vrfs__isnull", &local_var_str.to_string())]);
4412    }
4413    if let Some(ref local_var_str) = vrfs__n {
4414        local_var_req_builder = match "multi" {
4415            "multi" => local_var_req_builder.query(
4416                &local_var_str
4417                    .into_iter()
4418                    .map(|p| ("vrfs__n".to_owned(), p.to_string()))
4419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4420            ),
4421            _ => local_var_req_builder.query(&[(
4422                "vrfs__n",
4423                &local_var_str
4424                    .into_iter()
4425                    .map(|p| p.to_string())
4426                    .collect::<Vec<String>>()
4427                    .join(",")
4428                    .to_string(),
4429            )]),
4430        };
4431    }
4432    if let Some(ref local_var_str) = depth {
4433        local_var_req_builder =
4434            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4435    }
4436    if let Some(ref local_var_str) = exclude_m2m {
4437        local_var_req_builder =
4438            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4439    }
4440    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4441        local_var_req_builder =
4442            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4443    }
4444    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4445        let local_var_key = local_var_apikey.key.clone();
4446        let local_var_value = match local_var_apikey.prefix {
4447            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4448            None => local_var_key,
4449        };
4450        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4451    };
4452
4453    let local_var_req = local_var_req_builder.build()?;
4454    let local_var_resp = local_var_client.execute(local_var_req).await?;
4455
4456    let local_var_status = local_var_resp.status();
4457    let local_var_content = local_var_resp.text().await?;
4458
4459    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4460        serde_json::from_str(&local_var_content).map_err(Error::from)
4461    } else {
4462        let local_var_entity: Option<IpamIpAddressesListError> =
4463            serde_json::from_str(&local_var_content).ok();
4464        let local_var_error = ResponseContent {
4465            status: local_var_status,
4466            content: local_var_content,
4467            entity: local_var_entity,
4468        };
4469        Err(Error::ResponseError(local_var_error))
4470    }
4471}
4472
4473/// API methods for returning or creating notes on an object.
4474pub async fn ipam_ip_addresses_notes_create(
4475    configuration: &configuration::Configuration,
4476    id: &str,
4477    note_input_request: crate::models::NoteInputRequest,
4478    format: Option<&str>,
4479) -> Result<crate::models::Note, Error<IpamIpAddressesNotesCreateError>> {
4480    let local_var_configuration = configuration;
4481
4482    let local_var_client = &local_var_configuration.client;
4483
4484    let local_var_uri_str = format!(
4485        "{}/ipam/ip-addresses/{id}/notes/",
4486        local_var_configuration.base_path,
4487        id = crate::apis::urlencode(id)
4488    );
4489    let mut local_var_req_builder =
4490        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4491
4492    if let Some(ref local_var_str) = format {
4493        local_var_req_builder =
4494            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4495    }
4496    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4497        local_var_req_builder =
4498            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4499    }
4500    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4501        let local_var_key = local_var_apikey.key.clone();
4502        let local_var_value = match local_var_apikey.prefix {
4503            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4504            None => local_var_key,
4505        };
4506        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4507    };
4508    local_var_req_builder = local_var_req_builder.json(&note_input_request);
4509
4510    let local_var_req = local_var_req_builder.build()?;
4511    let local_var_resp = local_var_client.execute(local_var_req).await?;
4512
4513    let local_var_status = local_var_resp.status();
4514    let local_var_content = local_var_resp.text().await?;
4515
4516    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4517        serde_json::from_str(&local_var_content).map_err(Error::from)
4518    } else {
4519        let local_var_entity: Option<IpamIpAddressesNotesCreateError> =
4520            serde_json::from_str(&local_var_content).ok();
4521        let local_var_error = ResponseContent {
4522            status: local_var_status,
4523            content: local_var_content,
4524            entity: local_var_entity,
4525        };
4526        Err(Error::ResponseError(local_var_error))
4527    }
4528}
4529
4530/// API methods for returning or creating notes on an object.
4531pub async fn ipam_ip_addresses_notes_list(
4532    configuration: &configuration::Configuration,
4533    id: &str,
4534    format: Option<&str>,
4535    limit: Option<i32>,
4536    offset: Option<i32>,
4537    depth: Option<i32>,
4538    exclude_m2m: Option<bool>,
4539) -> Result<crate::models::PaginatedNoteList, Error<IpamIpAddressesNotesListError>> {
4540    let local_var_configuration = configuration;
4541
4542    let local_var_client = &local_var_configuration.client;
4543
4544    let local_var_uri_str = format!(
4545        "{}/ipam/ip-addresses/{id}/notes/",
4546        local_var_configuration.base_path,
4547        id = crate::apis::urlencode(id)
4548    );
4549    let mut local_var_req_builder =
4550        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4551
4552    if let Some(ref local_var_str) = format {
4553        local_var_req_builder =
4554            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4555    }
4556    if let Some(ref local_var_str) = limit {
4557        local_var_req_builder =
4558            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4559    }
4560    if let Some(ref local_var_str) = offset {
4561        local_var_req_builder =
4562            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4563    }
4564    if let Some(ref local_var_str) = depth {
4565        local_var_req_builder =
4566            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4567    }
4568    if let Some(ref local_var_str) = exclude_m2m {
4569        local_var_req_builder =
4570            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4571    }
4572    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4573        local_var_req_builder =
4574            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4575    }
4576    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4577        let local_var_key = local_var_apikey.key.clone();
4578        let local_var_value = match local_var_apikey.prefix {
4579            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4580            None => local_var_key,
4581        };
4582        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4583    };
4584
4585    let local_var_req = local_var_req_builder.build()?;
4586    let local_var_resp = local_var_client.execute(local_var_req).await?;
4587
4588    let local_var_status = local_var_resp.status();
4589    let local_var_content = local_var_resp.text().await?;
4590
4591    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4592        serde_json::from_str(&local_var_content).map_err(Error::from)
4593    } else {
4594        let local_var_entity: Option<IpamIpAddressesNotesListError> =
4595            serde_json::from_str(&local_var_content).ok();
4596        let local_var_error = ResponseContent {
4597            status: local_var_status,
4598            content: local_var_content,
4599            entity: local_var_entity,
4600        };
4601        Err(Error::ResponseError(local_var_error))
4602    }
4603}
4604
4605/// Partial update a IP address object.
4606pub async fn ipam_ip_addresses_partial_update(
4607    configuration: &configuration::Configuration,
4608    id: &str,
4609    format: Option<&str>,
4610    patched_ip_address_request: Option<crate::models::PatchedIpAddressRequest>,
4611) -> Result<crate::models::IpAddress, Error<IpamIpAddressesPartialUpdateError>> {
4612    let local_var_configuration = configuration;
4613
4614    let local_var_client = &local_var_configuration.client;
4615
4616    let local_var_uri_str = format!(
4617        "{}/ipam/ip-addresses/{id}/",
4618        local_var_configuration.base_path,
4619        id = crate::apis::urlencode(id)
4620    );
4621    let mut local_var_req_builder =
4622        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4623
4624    if let Some(ref local_var_str) = format {
4625        local_var_req_builder =
4626            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4627    }
4628    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4629        local_var_req_builder =
4630            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4631    }
4632    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4633        let local_var_key = local_var_apikey.key.clone();
4634        let local_var_value = match local_var_apikey.prefix {
4635            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4636            None => local_var_key,
4637        };
4638        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4639    };
4640    local_var_req_builder = local_var_req_builder.json(&patched_ip_address_request);
4641
4642    let local_var_req = local_var_req_builder.build()?;
4643    let local_var_resp = local_var_client.execute(local_var_req).await?;
4644
4645    let local_var_status = local_var_resp.status();
4646    let local_var_content = local_var_resp.text().await?;
4647
4648    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4649        serde_json::from_str(&local_var_content).map_err(Error::from)
4650    } else {
4651        let local_var_entity: Option<IpamIpAddressesPartialUpdateError> =
4652            serde_json::from_str(&local_var_content).ok();
4653        let local_var_error = ResponseContent {
4654            status: local_var_status,
4655            content: local_var_content,
4656            entity: local_var_entity,
4657        };
4658        Err(Error::ResponseError(local_var_error))
4659    }
4660}
4661
4662/// Retrieve a IP address object.
4663pub async fn ipam_ip_addresses_retrieve(
4664    configuration: &configuration::Configuration,
4665    id: &str,
4666    format: Option<&str>,
4667    depth: Option<i32>,
4668    exclude_m2m: Option<bool>,
4669) -> Result<crate::models::IpAddress, Error<IpamIpAddressesRetrieveError>> {
4670    let local_var_configuration = configuration;
4671
4672    let local_var_client = &local_var_configuration.client;
4673
4674    let local_var_uri_str = format!(
4675        "{}/ipam/ip-addresses/{id}/",
4676        local_var_configuration.base_path,
4677        id = crate::apis::urlencode(id)
4678    );
4679    let mut local_var_req_builder =
4680        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4681
4682    if let Some(ref local_var_str) = format {
4683        local_var_req_builder =
4684            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4685    }
4686    if let Some(ref local_var_str) = depth {
4687        local_var_req_builder =
4688            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4689    }
4690    if let Some(ref local_var_str) = exclude_m2m {
4691        local_var_req_builder =
4692            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4693    }
4694    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4695        local_var_req_builder =
4696            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4697    }
4698    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4699        let local_var_key = local_var_apikey.key.clone();
4700        let local_var_value = match local_var_apikey.prefix {
4701            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4702            None => local_var_key,
4703        };
4704        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4705    };
4706
4707    let local_var_req = local_var_req_builder.build()?;
4708    let local_var_resp = local_var_client.execute(local_var_req).await?;
4709
4710    let local_var_status = local_var_resp.status();
4711    let local_var_content = local_var_resp.text().await?;
4712
4713    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4714        serde_json::from_str(&local_var_content).map_err(Error::from)
4715    } else {
4716        let local_var_entity: Option<IpamIpAddressesRetrieveError> =
4717            serde_json::from_str(&local_var_content).ok();
4718        let local_var_error = ResponseContent {
4719            status: local_var_status,
4720            content: local_var_content,
4721            entity: local_var_entity,
4722        };
4723        Err(Error::ResponseError(local_var_error))
4724    }
4725}
4726
4727/// Update a IP address object.
4728pub async fn ipam_ip_addresses_update(
4729    configuration: &configuration::Configuration,
4730    id: &str,
4731    ip_address_request: crate::models::IpAddressRequest,
4732    format: Option<&str>,
4733) -> Result<crate::models::IpAddress, Error<IpamIpAddressesUpdateError>> {
4734    let local_var_configuration = configuration;
4735
4736    let local_var_client = &local_var_configuration.client;
4737
4738    let local_var_uri_str = format!(
4739        "{}/ipam/ip-addresses/{id}/",
4740        local_var_configuration.base_path,
4741        id = crate::apis::urlencode(id)
4742    );
4743    let mut local_var_req_builder =
4744        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4745
4746    if let Some(ref local_var_str) = format {
4747        local_var_req_builder =
4748            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4749    }
4750    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4751        local_var_req_builder =
4752            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4753    }
4754    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4755        let local_var_key = local_var_apikey.key.clone();
4756        let local_var_value = match local_var_apikey.prefix {
4757            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4758            None => local_var_key,
4759        };
4760        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4761    };
4762    local_var_req_builder = local_var_req_builder.json(&ip_address_request);
4763
4764    let local_var_req = local_var_req_builder.build()?;
4765    let local_var_resp = local_var_client.execute(local_var_req).await?;
4766
4767    let local_var_status = local_var_resp.status();
4768    let local_var_content = local_var_resp.text().await?;
4769
4770    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4771        serde_json::from_str(&local_var_content).map_err(Error::from)
4772    } else {
4773        let local_var_entity: Option<IpamIpAddressesUpdateError> =
4774            serde_json::from_str(&local_var_content).ok();
4775        let local_var_error = ResponseContent {
4776            status: local_var_status,
4777            content: local_var_content,
4778            entity: local_var_entity,
4779        };
4780        Err(Error::ResponseError(local_var_error))
4781    }
4782}
4783
4784/// Destroy a list of namespace objects.
4785pub async fn ipam_namespaces_bulk_destroy(
4786    configuration: &configuration::Configuration,
4787    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
4788    format: Option<&str>,
4789) -> Result<(), Error<IpamNamespacesBulkDestroyError>> {
4790    let local_var_configuration = configuration;
4791
4792    let local_var_client = &local_var_configuration.client;
4793
4794    let local_var_uri_str = format!("{}/ipam/namespaces/", local_var_configuration.base_path);
4795    let mut local_var_req_builder =
4796        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4797
4798    if let Some(ref local_var_str) = format {
4799        local_var_req_builder =
4800            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4801    }
4802    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4803        local_var_req_builder =
4804            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4805    }
4806    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4807        let local_var_key = local_var_apikey.key.clone();
4808        let local_var_value = match local_var_apikey.prefix {
4809            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4810            None => local_var_key,
4811        };
4812        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4813    };
4814    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
4815
4816    let local_var_req = local_var_req_builder.build()?;
4817    let local_var_resp = local_var_client.execute(local_var_req).await?;
4818
4819    let local_var_status = local_var_resp.status();
4820    let local_var_content = local_var_resp.text().await?;
4821
4822    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4823        Ok(())
4824    } else {
4825        let local_var_entity: Option<IpamNamespacesBulkDestroyError> =
4826            serde_json::from_str(&local_var_content).ok();
4827        let local_var_error = ResponseContent {
4828            status: local_var_status,
4829            content: local_var_content,
4830            entity: local_var_entity,
4831        };
4832        Err(Error::ResponseError(local_var_error))
4833    }
4834}
4835
4836/// Partial update a list of namespace objects.
4837pub async fn ipam_namespaces_bulk_partial_update(
4838    configuration: &configuration::Configuration,
4839    patched_bulk_writable_namespace_request: Vec<
4840        crate::models::PatchedBulkWritableNamespaceRequest,
4841    >,
4842    format: Option<&str>,
4843) -> Result<Vec<crate::models::Namespace>, Error<IpamNamespacesBulkPartialUpdateError>> {
4844    let local_var_configuration = configuration;
4845
4846    let local_var_client = &local_var_configuration.client;
4847
4848    let local_var_uri_str = format!("{}/ipam/namespaces/", local_var_configuration.base_path);
4849    let mut local_var_req_builder =
4850        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4851
4852    if let Some(ref local_var_str) = format {
4853        local_var_req_builder =
4854            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4855    }
4856    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4857        local_var_req_builder =
4858            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4859    }
4860    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4861        let local_var_key = local_var_apikey.key.clone();
4862        let local_var_value = match local_var_apikey.prefix {
4863            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4864            None => local_var_key,
4865        };
4866        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4867    };
4868    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_namespace_request);
4869
4870    let local_var_req = local_var_req_builder.build()?;
4871    let local_var_resp = local_var_client.execute(local_var_req).await?;
4872
4873    let local_var_status = local_var_resp.status();
4874    let local_var_content = local_var_resp.text().await?;
4875
4876    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4877        serde_json::from_str(&local_var_content).map_err(Error::from)
4878    } else {
4879        let local_var_entity: Option<IpamNamespacesBulkPartialUpdateError> =
4880            serde_json::from_str(&local_var_content).ok();
4881        let local_var_error = ResponseContent {
4882            status: local_var_status,
4883            content: local_var_content,
4884            entity: local_var_entity,
4885        };
4886        Err(Error::ResponseError(local_var_error))
4887    }
4888}
4889
4890/// Update a list of namespace objects.
4891pub async fn ipam_namespaces_bulk_update(
4892    configuration: &configuration::Configuration,
4893    bulk_writable_namespace_request: Vec<crate::models::BulkWritableNamespaceRequest>,
4894    format: Option<&str>,
4895) -> Result<Vec<crate::models::Namespace>, Error<IpamNamespacesBulkUpdateError>> {
4896    let local_var_configuration = configuration;
4897
4898    let local_var_client = &local_var_configuration.client;
4899
4900    let local_var_uri_str = format!("{}/ipam/namespaces/", local_var_configuration.base_path);
4901    let mut local_var_req_builder =
4902        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4903
4904    if let Some(ref local_var_str) = format {
4905        local_var_req_builder =
4906            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4907    }
4908    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4909        local_var_req_builder =
4910            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4911    }
4912    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4913        let local_var_key = local_var_apikey.key.clone();
4914        let local_var_value = match local_var_apikey.prefix {
4915            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4916            None => local_var_key,
4917        };
4918        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4919    };
4920    local_var_req_builder = local_var_req_builder.json(&bulk_writable_namespace_request);
4921
4922    let local_var_req = local_var_req_builder.build()?;
4923    let local_var_resp = local_var_client.execute(local_var_req).await?;
4924
4925    let local_var_status = local_var_resp.status();
4926    let local_var_content = local_var_resp.text().await?;
4927
4928    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4929        serde_json::from_str(&local_var_content).map_err(Error::from)
4930    } else {
4931        let local_var_entity: Option<IpamNamespacesBulkUpdateError> =
4932            serde_json::from_str(&local_var_content).ok();
4933        let local_var_error = ResponseContent {
4934            status: local_var_status,
4935            content: local_var_content,
4936            entity: local_var_entity,
4937        };
4938        Err(Error::ResponseError(local_var_error))
4939    }
4940}
4941
4942/// Create one or more namespace objects.
4943pub async fn ipam_namespaces_create(
4944    configuration: &configuration::Configuration,
4945    namespace_request: crate::models::NamespaceRequest,
4946    format: Option<&str>,
4947) -> Result<crate::models::Namespace, Error<IpamNamespacesCreateError>> {
4948    let local_var_configuration = configuration;
4949
4950    let local_var_client = &local_var_configuration.client;
4951
4952    let local_var_uri_str = format!("{}/ipam/namespaces/", local_var_configuration.base_path);
4953    let mut local_var_req_builder =
4954        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4955
4956    if let Some(ref local_var_str) = format {
4957        local_var_req_builder =
4958            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4959    }
4960    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4961        local_var_req_builder =
4962            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4963    }
4964    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4965        let local_var_key = local_var_apikey.key.clone();
4966        let local_var_value = match local_var_apikey.prefix {
4967            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4968            None => local_var_key,
4969        };
4970        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4971    };
4972    local_var_req_builder = local_var_req_builder.json(&namespace_request);
4973
4974    let local_var_req = local_var_req_builder.build()?;
4975    let local_var_resp = local_var_client.execute(local_var_req).await?;
4976
4977    let local_var_status = local_var_resp.status();
4978    let local_var_content = local_var_resp.text().await?;
4979
4980    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4981        serde_json::from_str(&local_var_content).map_err(Error::from)
4982    } else {
4983        let local_var_entity: Option<IpamNamespacesCreateError> =
4984            serde_json::from_str(&local_var_content).ok();
4985        let local_var_error = ResponseContent {
4986            status: local_var_status,
4987            content: local_var_content,
4988            entity: local_var_entity,
4989        };
4990        Err(Error::ResponseError(local_var_error))
4991    }
4992}
4993
4994/// Destroy a namespace object.
4995pub async fn ipam_namespaces_destroy(
4996    configuration: &configuration::Configuration,
4997    id: &str,
4998    format: Option<&str>,
4999) -> Result<(), Error<IpamNamespacesDestroyError>> {
5000    let local_var_configuration = configuration;
5001
5002    let local_var_client = &local_var_configuration.client;
5003
5004    let local_var_uri_str = format!(
5005        "{}/ipam/namespaces/{id}/",
5006        local_var_configuration.base_path,
5007        id = crate::apis::urlencode(id)
5008    );
5009    let mut local_var_req_builder =
5010        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5011
5012    if let Some(ref local_var_str) = format {
5013        local_var_req_builder =
5014            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5015    }
5016    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5017        local_var_req_builder =
5018            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5019    }
5020    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5021        let local_var_key = local_var_apikey.key.clone();
5022        let local_var_value = match local_var_apikey.prefix {
5023            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5024            None => local_var_key,
5025        };
5026        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5027    };
5028
5029    let local_var_req = local_var_req_builder.build()?;
5030    let local_var_resp = local_var_client.execute(local_var_req).await?;
5031
5032    let local_var_status = local_var_resp.status();
5033    let local_var_content = local_var_resp.text().await?;
5034
5035    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5036        Ok(())
5037    } else {
5038        let local_var_entity: Option<IpamNamespacesDestroyError> =
5039            serde_json::from_str(&local_var_content).ok();
5040        let local_var_error = ResponseContent {
5041            status: local_var_status,
5042            content: local_var_content,
5043            entity: local_var_entity,
5044        };
5045        Err(Error::ResponseError(local_var_error))
5046    }
5047}
5048
5049/// Retrieve a list of namespace objects.
5050pub async fn ipam_namespaces_list(
5051    configuration: &configuration::Configuration,
5052    contacts: Option<Vec<String>>,
5053    contacts__isnull: Option<bool>,
5054    contacts__n: Option<Vec<String>>,
5055    created: Option<Vec<String>>,
5056    created__gt: Option<Vec<String>>,
5057    created__gte: Option<Vec<String>>,
5058    created__isnull: Option<bool>,
5059    created__lt: Option<Vec<String>>,
5060    created__lte: Option<Vec<String>>,
5061    created__n: Option<Vec<String>>,
5062    description: Option<Vec<String>>,
5063    description__ic: Option<Vec<String>>,
5064    description__ie: Option<Vec<String>>,
5065    description__iew: Option<Vec<String>>,
5066    description__ire: Option<Vec<String>>,
5067    description__isw: Option<Vec<String>>,
5068    description__n: Option<Vec<String>>,
5069    description__nic: Option<Vec<String>>,
5070    description__nie: Option<Vec<String>>,
5071    description__niew: Option<Vec<String>>,
5072    description__nire: Option<Vec<String>>,
5073    description__nisw: Option<Vec<String>>,
5074    description__nre: Option<Vec<String>>,
5075    description__re: Option<Vec<String>>,
5076    dynamic_groups: Option<Vec<String>>,
5077    dynamic_groups__n: Option<Vec<String>>,
5078    format: Option<&str>,
5079    id: Option<Vec<uuid::Uuid>>,
5080    id__n: Option<Vec<uuid::Uuid>>,
5081    last_updated: Option<Vec<String>>,
5082    last_updated__gt: Option<Vec<String>>,
5083    last_updated__gte: Option<Vec<String>>,
5084    last_updated__isnull: Option<bool>,
5085    last_updated__lt: Option<Vec<String>>,
5086    last_updated__lte: Option<Vec<String>>,
5087    last_updated__n: Option<Vec<String>>,
5088    limit: Option<i32>,
5089    location: Option<Vec<uuid::Uuid>>,
5090    location__isnull: Option<bool>,
5091    location__n: Option<Vec<uuid::Uuid>>,
5092    name: Option<Vec<String>>,
5093    name__ic: Option<Vec<String>>,
5094    name__ie: Option<Vec<String>>,
5095    name__iew: Option<Vec<String>>,
5096    name__ire: Option<Vec<String>>,
5097    name__isw: Option<Vec<String>>,
5098    name__n: Option<Vec<String>>,
5099    name__nic: Option<Vec<String>>,
5100    name__nie: Option<Vec<String>>,
5101    name__niew: Option<Vec<String>>,
5102    name__nire: Option<Vec<String>>,
5103    name__nisw: Option<Vec<String>>,
5104    name__nre: Option<Vec<String>>,
5105    name__re: Option<Vec<String>>,
5106    offset: Option<i32>,
5107    q: Option<&str>,
5108    sort: Option<&str>,
5109    tags: Option<Vec<String>>,
5110    tags__isnull: Option<bool>,
5111    tags__n: Option<Vec<String>>,
5112    teams: Option<Vec<String>>,
5113    teams__isnull: Option<bool>,
5114    teams__n: Option<Vec<String>>,
5115    tenant: Option<Vec<String>>,
5116    tenant__isnull: Option<bool>,
5117    tenant__n: Option<Vec<String>>,
5118    tenant_group: Option<Vec<String>>,
5119    tenant_group__isnull: Option<bool>,
5120    tenant_group__n: Option<Vec<String>>,
5121    tenant_id: Option<Vec<uuid::Uuid>>,
5122    tenant_id__isnull: Option<bool>,
5123    tenant_id__n: Option<Vec<uuid::Uuid>>,
5124    depth: Option<i32>,
5125    exclude_m2m: Option<bool>,
5126) -> Result<crate::models::PaginatedNamespaceList, Error<IpamNamespacesListError>> {
5127    let local_var_configuration = configuration;
5128
5129    let local_var_client = &local_var_configuration.client;
5130
5131    let local_var_uri_str = format!("{}/ipam/namespaces/", local_var_configuration.base_path);
5132    let mut local_var_req_builder =
5133        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5134
5135    if let Some(ref local_var_str) = contacts {
5136        local_var_req_builder = match "multi" {
5137            "multi" => local_var_req_builder.query(
5138                &local_var_str
5139                    .into_iter()
5140                    .map(|p| ("contacts".to_owned(), p.to_string()))
5141                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5142            ),
5143            _ => local_var_req_builder.query(&[(
5144                "contacts",
5145                &local_var_str
5146                    .into_iter()
5147                    .map(|p| p.to_string())
5148                    .collect::<Vec<String>>()
5149                    .join(",")
5150                    .to_string(),
5151            )]),
5152        };
5153    }
5154    if let Some(ref local_var_str) = contacts__isnull {
5155        local_var_req_builder =
5156            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
5157    }
5158    if let Some(ref local_var_str) = contacts__n {
5159        local_var_req_builder = match "multi" {
5160            "multi" => local_var_req_builder.query(
5161                &local_var_str
5162                    .into_iter()
5163                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
5164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5165            ),
5166            _ => local_var_req_builder.query(&[(
5167                "contacts__n",
5168                &local_var_str
5169                    .into_iter()
5170                    .map(|p| p.to_string())
5171                    .collect::<Vec<String>>()
5172                    .join(",")
5173                    .to_string(),
5174            )]),
5175        };
5176    }
5177    if let Some(ref local_var_str) = created {
5178        local_var_req_builder = match "multi" {
5179            "multi" => local_var_req_builder.query(
5180                &local_var_str
5181                    .into_iter()
5182                    .map(|p| ("created".to_owned(), p.to_string()))
5183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5184            ),
5185            _ => local_var_req_builder.query(&[(
5186                "created",
5187                &local_var_str
5188                    .into_iter()
5189                    .map(|p| p.to_string())
5190                    .collect::<Vec<String>>()
5191                    .join(",")
5192                    .to_string(),
5193            )]),
5194        };
5195    }
5196    if let Some(ref local_var_str) = created__gt {
5197        local_var_req_builder = match "multi" {
5198            "multi" => local_var_req_builder.query(
5199                &local_var_str
5200                    .into_iter()
5201                    .map(|p| ("created__gt".to_owned(), p.to_string()))
5202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5203            ),
5204            _ => local_var_req_builder.query(&[(
5205                "created__gt",
5206                &local_var_str
5207                    .into_iter()
5208                    .map(|p| p.to_string())
5209                    .collect::<Vec<String>>()
5210                    .join(",")
5211                    .to_string(),
5212            )]),
5213        };
5214    }
5215    if let Some(ref local_var_str) = created__gte {
5216        local_var_req_builder = match "multi" {
5217            "multi" => local_var_req_builder.query(
5218                &local_var_str
5219                    .into_iter()
5220                    .map(|p| ("created__gte".to_owned(), p.to_string()))
5221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5222            ),
5223            _ => local_var_req_builder.query(&[(
5224                "created__gte",
5225                &local_var_str
5226                    .into_iter()
5227                    .map(|p| p.to_string())
5228                    .collect::<Vec<String>>()
5229                    .join(",")
5230                    .to_string(),
5231            )]),
5232        };
5233    }
5234    if let Some(ref local_var_str) = created__isnull {
5235        local_var_req_builder =
5236            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
5237    }
5238    if let Some(ref local_var_str) = created__lt {
5239        local_var_req_builder = match "multi" {
5240            "multi" => local_var_req_builder.query(
5241                &local_var_str
5242                    .into_iter()
5243                    .map(|p| ("created__lt".to_owned(), p.to_string()))
5244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5245            ),
5246            _ => local_var_req_builder.query(&[(
5247                "created__lt",
5248                &local_var_str
5249                    .into_iter()
5250                    .map(|p| p.to_string())
5251                    .collect::<Vec<String>>()
5252                    .join(",")
5253                    .to_string(),
5254            )]),
5255        };
5256    }
5257    if let Some(ref local_var_str) = created__lte {
5258        local_var_req_builder = match "multi" {
5259            "multi" => local_var_req_builder.query(
5260                &local_var_str
5261                    .into_iter()
5262                    .map(|p| ("created__lte".to_owned(), p.to_string()))
5263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5264            ),
5265            _ => local_var_req_builder.query(&[(
5266                "created__lte",
5267                &local_var_str
5268                    .into_iter()
5269                    .map(|p| p.to_string())
5270                    .collect::<Vec<String>>()
5271                    .join(",")
5272                    .to_string(),
5273            )]),
5274        };
5275    }
5276    if let Some(ref local_var_str) = created__n {
5277        local_var_req_builder = match "multi" {
5278            "multi" => local_var_req_builder.query(
5279                &local_var_str
5280                    .into_iter()
5281                    .map(|p| ("created__n".to_owned(), p.to_string()))
5282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5283            ),
5284            _ => local_var_req_builder.query(&[(
5285                "created__n",
5286                &local_var_str
5287                    .into_iter()
5288                    .map(|p| p.to_string())
5289                    .collect::<Vec<String>>()
5290                    .join(",")
5291                    .to_string(),
5292            )]),
5293        };
5294    }
5295    if let Some(ref local_var_str) = description {
5296        local_var_req_builder = match "multi" {
5297            "multi" => local_var_req_builder.query(
5298                &local_var_str
5299                    .into_iter()
5300                    .map(|p| ("description".to_owned(), p.to_string()))
5301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5302            ),
5303            _ => local_var_req_builder.query(&[(
5304                "description",
5305                &local_var_str
5306                    .into_iter()
5307                    .map(|p| p.to_string())
5308                    .collect::<Vec<String>>()
5309                    .join(",")
5310                    .to_string(),
5311            )]),
5312        };
5313    }
5314    if let Some(ref local_var_str) = description__ic {
5315        local_var_req_builder = match "multi" {
5316            "multi" => local_var_req_builder.query(
5317                &local_var_str
5318                    .into_iter()
5319                    .map(|p| ("description__ic".to_owned(), p.to_string()))
5320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5321            ),
5322            _ => local_var_req_builder.query(&[(
5323                "description__ic",
5324                &local_var_str
5325                    .into_iter()
5326                    .map(|p| p.to_string())
5327                    .collect::<Vec<String>>()
5328                    .join(",")
5329                    .to_string(),
5330            )]),
5331        };
5332    }
5333    if let Some(ref local_var_str) = description__ie {
5334        local_var_req_builder = match "multi" {
5335            "multi" => local_var_req_builder.query(
5336                &local_var_str
5337                    .into_iter()
5338                    .map(|p| ("description__ie".to_owned(), p.to_string()))
5339                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5340            ),
5341            _ => local_var_req_builder.query(&[(
5342                "description__ie",
5343                &local_var_str
5344                    .into_iter()
5345                    .map(|p| p.to_string())
5346                    .collect::<Vec<String>>()
5347                    .join(",")
5348                    .to_string(),
5349            )]),
5350        };
5351    }
5352    if let Some(ref local_var_str) = description__iew {
5353        local_var_req_builder = match "multi" {
5354            "multi" => local_var_req_builder.query(
5355                &local_var_str
5356                    .into_iter()
5357                    .map(|p| ("description__iew".to_owned(), p.to_string()))
5358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5359            ),
5360            _ => local_var_req_builder.query(&[(
5361                "description__iew",
5362                &local_var_str
5363                    .into_iter()
5364                    .map(|p| p.to_string())
5365                    .collect::<Vec<String>>()
5366                    .join(",")
5367                    .to_string(),
5368            )]),
5369        };
5370    }
5371    if let Some(ref local_var_str) = description__ire {
5372        local_var_req_builder = match "multi" {
5373            "multi" => local_var_req_builder.query(
5374                &local_var_str
5375                    .into_iter()
5376                    .map(|p| ("description__ire".to_owned(), p.to_string()))
5377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5378            ),
5379            _ => local_var_req_builder.query(&[(
5380                "description__ire",
5381                &local_var_str
5382                    .into_iter()
5383                    .map(|p| p.to_string())
5384                    .collect::<Vec<String>>()
5385                    .join(",")
5386                    .to_string(),
5387            )]),
5388        };
5389    }
5390    if let Some(ref local_var_str) = description__isw {
5391        local_var_req_builder = match "multi" {
5392            "multi" => local_var_req_builder.query(
5393                &local_var_str
5394                    .into_iter()
5395                    .map(|p| ("description__isw".to_owned(), p.to_string()))
5396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5397            ),
5398            _ => local_var_req_builder.query(&[(
5399                "description__isw",
5400                &local_var_str
5401                    .into_iter()
5402                    .map(|p| p.to_string())
5403                    .collect::<Vec<String>>()
5404                    .join(",")
5405                    .to_string(),
5406            )]),
5407        };
5408    }
5409    if let Some(ref local_var_str) = description__n {
5410        local_var_req_builder = match "multi" {
5411            "multi" => local_var_req_builder.query(
5412                &local_var_str
5413                    .into_iter()
5414                    .map(|p| ("description__n".to_owned(), p.to_string()))
5415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5416            ),
5417            _ => local_var_req_builder.query(&[(
5418                "description__n",
5419                &local_var_str
5420                    .into_iter()
5421                    .map(|p| p.to_string())
5422                    .collect::<Vec<String>>()
5423                    .join(",")
5424                    .to_string(),
5425            )]),
5426        };
5427    }
5428    if let Some(ref local_var_str) = description__nic {
5429        local_var_req_builder = match "multi" {
5430            "multi" => local_var_req_builder.query(
5431                &local_var_str
5432                    .into_iter()
5433                    .map(|p| ("description__nic".to_owned(), p.to_string()))
5434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5435            ),
5436            _ => local_var_req_builder.query(&[(
5437                "description__nic",
5438                &local_var_str
5439                    .into_iter()
5440                    .map(|p| p.to_string())
5441                    .collect::<Vec<String>>()
5442                    .join(",")
5443                    .to_string(),
5444            )]),
5445        };
5446    }
5447    if let Some(ref local_var_str) = description__nie {
5448        local_var_req_builder = match "multi" {
5449            "multi" => local_var_req_builder.query(
5450                &local_var_str
5451                    .into_iter()
5452                    .map(|p| ("description__nie".to_owned(), p.to_string()))
5453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5454            ),
5455            _ => local_var_req_builder.query(&[(
5456                "description__nie",
5457                &local_var_str
5458                    .into_iter()
5459                    .map(|p| p.to_string())
5460                    .collect::<Vec<String>>()
5461                    .join(",")
5462                    .to_string(),
5463            )]),
5464        };
5465    }
5466    if let Some(ref local_var_str) = description__niew {
5467        local_var_req_builder = match "multi" {
5468            "multi" => local_var_req_builder.query(
5469                &local_var_str
5470                    .into_iter()
5471                    .map(|p| ("description__niew".to_owned(), p.to_string()))
5472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5473            ),
5474            _ => local_var_req_builder.query(&[(
5475                "description__niew",
5476                &local_var_str
5477                    .into_iter()
5478                    .map(|p| p.to_string())
5479                    .collect::<Vec<String>>()
5480                    .join(",")
5481                    .to_string(),
5482            )]),
5483        };
5484    }
5485    if let Some(ref local_var_str) = description__nire {
5486        local_var_req_builder = match "multi" {
5487            "multi" => local_var_req_builder.query(
5488                &local_var_str
5489                    .into_iter()
5490                    .map(|p| ("description__nire".to_owned(), p.to_string()))
5491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5492            ),
5493            _ => local_var_req_builder.query(&[(
5494                "description__nire",
5495                &local_var_str
5496                    .into_iter()
5497                    .map(|p| p.to_string())
5498                    .collect::<Vec<String>>()
5499                    .join(",")
5500                    .to_string(),
5501            )]),
5502        };
5503    }
5504    if let Some(ref local_var_str) = description__nisw {
5505        local_var_req_builder = match "multi" {
5506            "multi" => local_var_req_builder.query(
5507                &local_var_str
5508                    .into_iter()
5509                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
5510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5511            ),
5512            _ => local_var_req_builder.query(&[(
5513                "description__nisw",
5514                &local_var_str
5515                    .into_iter()
5516                    .map(|p| p.to_string())
5517                    .collect::<Vec<String>>()
5518                    .join(",")
5519                    .to_string(),
5520            )]),
5521        };
5522    }
5523    if let Some(ref local_var_str) = description__nre {
5524        local_var_req_builder = match "multi" {
5525            "multi" => local_var_req_builder.query(
5526                &local_var_str
5527                    .into_iter()
5528                    .map(|p| ("description__nre".to_owned(), p.to_string()))
5529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5530            ),
5531            _ => local_var_req_builder.query(&[(
5532                "description__nre",
5533                &local_var_str
5534                    .into_iter()
5535                    .map(|p| p.to_string())
5536                    .collect::<Vec<String>>()
5537                    .join(",")
5538                    .to_string(),
5539            )]),
5540        };
5541    }
5542    if let Some(ref local_var_str) = description__re {
5543        local_var_req_builder = match "multi" {
5544            "multi" => local_var_req_builder.query(
5545                &local_var_str
5546                    .into_iter()
5547                    .map(|p| ("description__re".to_owned(), p.to_string()))
5548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5549            ),
5550            _ => local_var_req_builder.query(&[(
5551                "description__re",
5552                &local_var_str
5553                    .into_iter()
5554                    .map(|p| p.to_string())
5555                    .collect::<Vec<String>>()
5556                    .join(",")
5557                    .to_string(),
5558            )]),
5559        };
5560    }
5561    if let Some(ref local_var_str) = dynamic_groups {
5562        local_var_req_builder = match "multi" {
5563            "multi" => local_var_req_builder.query(
5564                &local_var_str
5565                    .into_iter()
5566                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
5567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5568            ),
5569            _ => local_var_req_builder.query(&[(
5570                "dynamic_groups",
5571                &local_var_str
5572                    .into_iter()
5573                    .map(|p| p.to_string())
5574                    .collect::<Vec<String>>()
5575                    .join(",")
5576                    .to_string(),
5577            )]),
5578        };
5579    }
5580    if let Some(ref local_var_str) = dynamic_groups__n {
5581        local_var_req_builder = match "multi" {
5582            "multi" => local_var_req_builder.query(
5583                &local_var_str
5584                    .into_iter()
5585                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
5586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5587            ),
5588            _ => local_var_req_builder.query(&[(
5589                "dynamic_groups__n",
5590                &local_var_str
5591                    .into_iter()
5592                    .map(|p| p.to_string())
5593                    .collect::<Vec<String>>()
5594                    .join(",")
5595                    .to_string(),
5596            )]),
5597        };
5598    }
5599    if let Some(ref local_var_str) = format {
5600        local_var_req_builder =
5601            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5602    }
5603    if let Some(ref local_var_str) = id {
5604        local_var_req_builder = match "multi" {
5605            "multi" => local_var_req_builder.query(
5606                &local_var_str
5607                    .into_iter()
5608                    .map(|p| ("id".to_owned(), p.to_string()))
5609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5610            ),
5611            _ => local_var_req_builder.query(&[(
5612                "id",
5613                &local_var_str
5614                    .into_iter()
5615                    .map(|p| p.to_string())
5616                    .collect::<Vec<String>>()
5617                    .join(",")
5618                    .to_string(),
5619            )]),
5620        };
5621    }
5622    if let Some(ref local_var_str) = id__n {
5623        local_var_req_builder = match "multi" {
5624            "multi" => local_var_req_builder.query(
5625                &local_var_str
5626                    .into_iter()
5627                    .map(|p| ("id__n".to_owned(), p.to_string()))
5628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5629            ),
5630            _ => local_var_req_builder.query(&[(
5631                "id__n",
5632                &local_var_str
5633                    .into_iter()
5634                    .map(|p| p.to_string())
5635                    .collect::<Vec<String>>()
5636                    .join(",")
5637                    .to_string(),
5638            )]),
5639        };
5640    }
5641    if let Some(ref local_var_str) = last_updated {
5642        local_var_req_builder = match "multi" {
5643            "multi" => local_var_req_builder.query(
5644                &local_var_str
5645                    .into_iter()
5646                    .map(|p| ("last_updated".to_owned(), p.to_string()))
5647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5648            ),
5649            _ => local_var_req_builder.query(&[(
5650                "last_updated",
5651                &local_var_str
5652                    .into_iter()
5653                    .map(|p| p.to_string())
5654                    .collect::<Vec<String>>()
5655                    .join(",")
5656                    .to_string(),
5657            )]),
5658        };
5659    }
5660    if let Some(ref local_var_str) = last_updated__gt {
5661        local_var_req_builder = match "multi" {
5662            "multi" => local_var_req_builder.query(
5663                &local_var_str
5664                    .into_iter()
5665                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
5666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5667            ),
5668            _ => local_var_req_builder.query(&[(
5669                "last_updated__gt",
5670                &local_var_str
5671                    .into_iter()
5672                    .map(|p| p.to_string())
5673                    .collect::<Vec<String>>()
5674                    .join(",")
5675                    .to_string(),
5676            )]),
5677        };
5678    }
5679    if let Some(ref local_var_str) = last_updated__gte {
5680        local_var_req_builder = match "multi" {
5681            "multi" => local_var_req_builder.query(
5682                &local_var_str
5683                    .into_iter()
5684                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
5685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5686            ),
5687            _ => local_var_req_builder.query(&[(
5688                "last_updated__gte",
5689                &local_var_str
5690                    .into_iter()
5691                    .map(|p| p.to_string())
5692                    .collect::<Vec<String>>()
5693                    .join(",")
5694                    .to_string(),
5695            )]),
5696        };
5697    }
5698    if let Some(ref local_var_str) = last_updated__isnull {
5699        local_var_req_builder =
5700            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
5701    }
5702    if let Some(ref local_var_str) = last_updated__lt {
5703        local_var_req_builder = match "multi" {
5704            "multi" => local_var_req_builder.query(
5705                &local_var_str
5706                    .into_iter()
5707                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
5708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5709            ),
5710            _ => local_var_req_builder.query(&[(
5711                "last_updated__lt",
5712                &local_var_str
5713                    .into_iter()
5714                    .map(|p| p.to_string())
5715                    .collect::<Vec<String>>()
5716                    .join(",")
5717                    .to_string(),
5718            )]),
5719        };
5720    }
5721    if let Some(ref local_var_str) = last_updated__lte {
5722        local_var_req_builder = match "multi" {
5723            "multi" => local_var_req_builder.query(
5724                &local_var_str
5725                    .into_iter()
5726                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
5727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5728            ),
5729            _ => local_var_req_builder.query(&[(
5730                "last_updated__lte",
5731                &local_var_str
5732                    .into_iter()
5733                    .map(|p| p.to_string())
5734                    .collect::<Vec<String>>()
5735                    .join(",")
5736                    .to_string(),
5737            )]),
5738        };
5739    }
5740    if let Some(ref local_var_str) = last_updated__n {
5741        local_var_req_builder = match "multi" {
5742            "multi" => local_var_req_builder.query(
5743                &local_var_str
5744                    .into_iter()
5745                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5747            ),
5748            _ => local_var_req_builder.query(&[(
5749                "last_updated__n",
5750                &local_var_str
5751                    .into_iter()
5752                    .map(|p| p.to_string())
5753                    .collect::<Vec<String>>()
5754                    .join(",")
5755                    .to_string(),
5756            )]),
5757        };
5758    }
5759    if let Some(ref local_var_str) = limit {
5760        local_var_req_builder =
5761            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5762    }
5763    if let Some(ref local_var_str) = location {
5764        local_var_req_builder = match "multi" {
5765            "multi" => local_var_req_builder.query(
5766                &local_var_str
5767                    .into_iter()
5768                    .map(|p| ("location".to_owned(), p.to_string()))
5769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5770            ),
5771            _ => local_var_req_builder.query(&[(
5772                "location",
5773                &local_var_str
5774                    .into_iter()
5775                    .map(|p| p.to_string())
5776                    .collect::<Vec<String>>()
5777                    .join(",")
5778                    .to_string(),
5779            )]),
5780        };
5781    }
5782    if let Some(ref local_var_str) = location__isnull {
5783        local_var_req_builder =
5784            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
5785    }
5786    if let Some(ref local_var_str) = location__n {
5787        local_var_req_builder = match "multi" {
5788            "multi" => local_var_req_builder.query(
5789                &local_var_str
5790                    .into_iter()
5791                    .map(|p| ("location__n".to_owned(), p.to_string()))
5792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5793            ),
5794            _ => local_var_req_builder.query(&[(
5795                "location__n",
5796                &local_var_str
5797                    .into_iter()
5798                    .map(|p| p.to_string())
5799                    .collect::<Vec<String>>()
5800                    .join(",")
5801                    .to_string(),
5802            )]),
5803        };
5804    }
5805    if let Some(ref local_var_str) = name {
5806        local_var_req_builder = match "multi" {
5807            "multi" => local_var_req_builder.query(
5808                &local_var_str
5809                    .into_iter()
5810                    .map(|p| ("name".to_owned(), p.to_string()))
5811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5812            ),
5813            _ => local_var_req_builder.query(&[(
5814                "name",
5815                &local_var_str
5816                    .into_iter()
5817                    .map(|p| p.to_string())
5818                    .collect::<Vec<String>>()
5819                    .join(",")
5820                    .to_string(),
5821            )]),
5822        };
5823    }
5824    if let Some(ref local_var_str) = name__ic {
5825        local_var_req_builder = match "multi" {
5826            "multi" => local_var_req_builder.query(
5827                &local_var_str
5828                    .into_iter()
5829                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5831            ),
5832            _ => local_var_req_builder.query(&[(
5833                "name__ic",
5834                &local_var_str
5835                    .into_iter()
5836                    .map(|p| p.to_string())
5837                    .collect::<Vec<String>>()
5838                    .join(",")
5839                    .to_string(),
5840            )]),
5841        };
5842    }
5843    if let Some(ref local_var_str) = name__ie {
5844        local_var_req_builder = match "multi" {
5845            "multi" => local_var_req_builder.query(
5846                &local_var_str
5847                    .into_iter()
5848                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5850            ),
5851            _ => local_var_req_builder.query(&[(
5852                "name__ie",
5853                &local_var_str
5854                    .into_iter()
5855                    .map(|p| p.to_string())
5856                    .collect::<Vec<String>>()
5857                    .join(",")
5858                    .to_string(),
5859            )]),
5860        };
5861    }
5862    if let Some(ref local_var_str) = name__iew {
5863        local_var_req_builder = match "multi" {
5864            "multi" => local_var_req_builder.query(
5865                &local_var_str
5866                    .into_iter()
5867                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5869            ),
5870            _ => local_var_req_builder.query(&[(
5871                "name__iew",
5872                &local_var_str
5873                    .into_iter()
5874                    .map(|p| p.to_string())
5875                    .collect::<Vec<String>>()
5876                    .join(",")
5877                    .to_string(),
5878            )]),
5879        };
5880    }
5881    if let Some(ref local_var_str) = name__ire {
5882        local_var_req_builder = match "multi" {
5883            "multi" => local_var_req_builder.query(
5884                &local_var_str
5885                    .into_iter()
5886                    .map(|p| ("name__ire".to_owned(), p.to_string()))
5887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5888            ),
5889            _ => local_var_req_builder.query(&[(
5890                "name__ire",
5891                &local_var_str
5892                    .into_iter()
5893                    .map(|p| p.to_string())
5894                    .collect::<Vec<String>>()
5895                    .join(",")
5896                    .to_string(),
5897            )]),
5898        };
5899    }
5900    if let Some(ref local_var_str) = name__isw {
5901        local_var_req_builder = match "multi" {
5902            "multi" => local_var_req_builder.query(
5903                &local_var_str
5904                    .into_iter()
5905                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5907            ),
5908            _ => local_var_req_builder.query(&[(
5909                "name__isw",
5910                &local_var_str
5911                    .into_iter()
5912                    .map(|p| p.to_string())
5913                    .collect::<Vec<String>>()
5914                    .join(",")
5915                    .to_string(),
5916            )]),
5917        };
5918    }
5919    if let Some(ref local_var_str) = name__n {
5920        local_var_req_builder = match "multi" {
5921            "multi" => local_var_req_builder.query(
5922                &local_var_str
5923                    .into_iter()
5924                    .map(|p| ("name__n".to_owned(), p.to_string()))
5925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5926            ),
5927            _ => local_var_req_builder.query(&[(
5928                "name__n",
5929                &local_var_str
5930                    .into_iter()
5931                    .map(|p| p.to_string())
5932                    .collect::<Vec<String>>()
5933                    .join(",")
5934                    .to_string(),
5935            )]),
5936        };
5937    }
5938    if let Some(ref local_var_str) = name__nic {
5939        local_var_req_builder = match "multi" {
5940            "multi" => local_var_req_builder.query(
5941                &local_var_str
5942                    .into_iter()
5943                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5945            ),
5946            _ => local_var_req_builder.query(&[(
5947                "name__nic",
5948                &local_var_str
5949                    .into_iter()
5950                    .map(|p| p.to_string())
5951                    .collect::<Vec<String>>()
5952                    .join(",")
5953                    .to_string(),
5954            )]),
5955        };
5956    }
5957    if let Some(ref local_var_str) = name__nie {
5958        local_var_req_builder = match "multi" {
5959            "multi" => local_var_req_builder.query(
5960                &local_var_str
5961                    .into_iter()
5962                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5964            ),
5965            _ => local_var_req_builder.query(&[(
5966                "name__nie",
5967                &local_var_str
5968                    .into_iter()
5969                    .map(|p| p.to_string())
5970                    .collect::<Vec<String>>()
5971                    .join(",")
5972                    .to_string(),
5973            )]),
5974        };
5975    }
5976    if let Some(ref local_var_str) = name__niew {
5977        local_var_req_builder = match "multi" {
5978            "multi" => local_var_req_builder.query(
5979                &local_var_str
5980                    .into_iter()
5981                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5983            ),
5984            _ => local_var_req_builder.query(&[(
5985                "name__niew",
5986                &local_var_str
5987                    .into_iter()
5988                    .map(|p| p.to_string())
5989                    .collect::<Vec<String>>()
5990                    .join(",")
5991                    .to_string(),
5992            )]),
5993        };
5994    }
5995    if let Some(ref local_var_str) = name__nire {
5996        local_var_req_builder = match "multi" {
5997            "multi" => local_var_req_builder.query(
5998                &local_var_str
5999                    .into_iter()
6000                    .map(|p| ("name__nire".to_owned(), p.to_string()))
6001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6002            ),
6003            _ => local_var_req_builder.query(&[(
6004                "name__nire",
6005                &local_var_str
6006                    .into_iter()
6007                    .map(|p| p.to_string())
6008                    .collect::<Vec<String>>()
6009                    .join(",")
6010                    .to_string(),
6011            )]),
6012        };
6013    }
6014    if let Some(ref local_var_str) = name__nisw {
6015        local_var_req_builder = match "multi" {
6016            "multi" => local_var_req_builder.query(
6017                &local_var_str
6018                    .into_iter()
6019                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
6020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6021            ),
6022            _ => local_var_req_builder.query(&[(
6023                "name__nisw",
6024                &local_var_str
6025                    .into_iter()
6026                    .map(|p| p.to_string())
6027                    .collect::<Vec<String>>()
6028                    .join(",")
6029                    .to_string(),
6030            )]),
6031        };
6032    }
6033    if let Some(ref local_var_str) = name__nre {
6034        local_var_req_builder = match "multi" {
6035            "multi" => local_var_req_builder.query(
6036                &local_var_str
6037                    .into_iter()
6038                    .map(|p| ("name__nre".to_owned(), p.to_string()))
6039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6040            ),
6041            _ => local_var_req_builder.query(&[(
6042                "name__nre",
6043                &local_var_str
6044                    .into_iter()
6045                    .map(|p| p.to_string())
6046                    .collect::<Vec<String>>()
6047                    .join(",")
6048                    .to_string(),
6049            )]),
6050        };
6051    }
6052    if let Some(ref local_var_str) = name__re {
6053        local_var_req_builder = match "multi" {
6054            "multi" => local_var_req_builder.query(
6055                &local_var_str
6056                    .into_iter()
6057                    .map(|p| ("name__re".to_owned(), p.to_string()))
6058                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6059            ),
6060            _ => local_var_req_builder.query(&[(
6061                "name__re",
6062                &local_var_str
6063                    .into_iter()
6064                    .map(|p| p.to_string())
6065                    .collect::<Vec<String>>()
6066                    .join(",")
6067                    .to_string(),
6068            )]),
6069        };
6070    }
6071    if let Some(ref local_var_str) = offset {
6072        local_var_req_builder =
6073            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6074    }
6075    if let Some(ref local_var_str) = q {
6076        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6077    }
6078    if let Some(ref local_var_str) = sort {
6079        local_var_req_builder =
6080            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
6081    }
6082    if let Some(ref local_var_str) = tags {
6083        local_var_req_builder = match "multi" {
6084            "multi" => local_var_req_builder.query(
6085                &local_var_str
6086                    .into_iter()
6087                    .map(|p| ("tags".to_owned(), p.to_string()))
6088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6089            ),
6090            _ => local_var_req_builder.query(&[(
6091                "tags",
6092                &local_var_str
6093                    .into_iter()
6094                    .map(|p| p.to_string())
6095                    .collect::<Vec<String>>()
6096                    .join(",")
6097                    .to_string(),
6098            )]),
6099        };
6100    }
6101    if let Some(ref local_var_str) = tags__isnull {
6102        local_var_req_builder =
6103            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
6104    }
6105    if let Some(ref local_var_str) = tags__n {
6106        local_var_req_builder = match "multi" {
6107            "multi" => local_var_req_builder.query(
6108                &local_var_str
6109                    .into_iter()
6110                    .map(|p| ("tags__n".to_owned(), p.to_string()))
6111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6112            ),
6113            _ => local_var_req_builder.query(&[(
6114                "tags__n",
6115                &local_var_str
6116                    .into_iter()
6117                    .map(|p| p.to_string())
6118                    .collect::<Vec<String>>()
6119                    .join(",")
6120                    .to_string(),
6121            )]),
6122        };
6123    }
6124    if let Some(ref local_var_str) = teams {
6125        local_var_req_builder = match "multi" {
6126            "multi" => local_var_req_builder.query(
6127                &local_var_str
6128                    .into_iter()
6129                    .map(|p| ("teams".to_owned(), p.to_string()))
6130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6131            ),
6132            _ => local_var_req_builder.query(&[(
6133                "teams",
6134                &local_var_str
6135                    .into_iter()
6136                    .map(|p| p.to_string())
6137                    .collect::<Vec<String>>()
6138                    .join(",")
6139                    .to_string(),
6140            )]),
6141        };
6142    }
6143    if let Some(ref local_var_str) = teams__isnull {
6144        local_var_req_builder =
6145            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
6146    }
6147    if let Some(ref local_var_str) = teams__n {
6148        local_var_req_builder = match "multi" {
6149            "multi" => local_var_req_builder.query(
6150                &local_var_str
6151                    .into_iter()
6152                    .map(|p| ("teams__n".to_owned(), p.to_string()))
6153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6154            ),
6155            _ => local_var_req_builder.query(&[(
6156                "teams__n",
6157                &local_var_str
6158                    .into_iter()
6159                    .map(|p| p.to_string())
6160                    .collect::<Vec<String>>()
6161                    .join(",")
6162                    .to_string(),
6163            )]),
6164        };
6165    }
6166    if let Some(ref local_var_str) = tenant {
6167        local_var_req_builder = match "multi" {
6168            "multi" => local_var_req_builder.query(
6169                &local_var_str
6170                    .into_iter()
6171                    .map(|p| ("tenant".to_owned(), p.to_string()))
6172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6173            ),
6174            _ => local_var_req_builder.query(&[(
6175                "tenant",
6176                &local_var_str
6177                    .into_iter()
6178                    .map(|p| p.to_string())
6179                    .collect::<Vec<String>>()
6180                    .join(",")
6181                    .to_string(),
6182            )]),
6183        };
6184    }
6185    if let Some(ref local_var_str) = tenant__isnull {
6186        local_var_req_builder =
6187            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
6188    }
6189    if let Some(ref local_var_str) = tenant__n {
6190        local_var_req_builder = match "multi" {
6191            "multi" => local_var_req_builder.query(
6192                &local_var_str
6193                    .into_iter()
6194                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
6195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6196            ),
6197            _ => local_var_req_builder.query(&[(
6198                "tenant__n",
6199                &local_var_str
6200                    .into_iter()
6201                    .map(|p| p.to_string())
6202                    .collect::<Vec<String>>()
6203                    .join(",")
6204                    .to_string(),
6205            )]),
6206        };
6207    }
6208    if let Some(ref local_var_str) = tenant_group {
6209        local_var_req_builder = match "multi" {
6210            "multi" => local_var_req_builder.query(
6211                &local_var_str
6212                    .into_iter()
6213                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
6214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6215            ),
6216            _ => local_var_req_builder.query(&[(
6217                "tenant_group",
6218                &local_var_str
6219                    .into_iter()
6220                    .map(|p| p.to_string())
6221                    .collect::<Vec<String>>()
6222                    .join(",")
6223                    .to_string(),
6224            )]),
6225        };
6226    }
6227    if let Some(ref local_var_str) = tenant_group__isnull {
6228        local_var_req_builder =
6229            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
6230    }
6231    if let Some(ref local_var_str) = tenant_group__n {
6232        local_var_req_builder = match "multi" {
6233            "multi" => local_var_req_builder.query(
6234                &local_var_str
6235                    .into_iter()
6236                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
6237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6238            ),
6239            _ => local_var_req_builder.query(&[(
6240                "tenant_group__n",
6241                &local_var_str
6242                    .into_iter()
6243                    .map(|p| p.to_string())
6244                    .collect::<Vec<String>>()
6245                    .join(",")
6246                    .to_string(),
6247            )]),
6248        };
6249    }
6250    if let Some(ref local_var_str) = tenant_id {
6251        local_var_req_builder = match "multi" {
6252            "multi" => local_var_req_builder.query(
6253                &local_var_str
6254                    .into_iter()
6255                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
6256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6257            ),
6258            _ => local_var_req_builder.query(&[(
6259                "tenant_id",
6260                &local_var_str
6261                    .into_iter()
6262                    .map(|p| p.to_string())
6263                    .collect::<Vec<String>>()
6264                    .join(",")
6265                    .to_string(),
6266            )]),
6267        };
6268    }
6269    if let Some(ref local_var_str) = tenant_id__isnull {
6270        local_var_req_builder =
6271            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
6272    }
6273    if let Some(ref local_var_str) = tenant_id__n {
6274        local_var_req_builder = match "multi" {
6275            "multi" => local_var_req_builder.query(
6276                &local_var_str
6277                    .into_iter()
6278                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
6279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6280            ),
6281            _ => local_var_req_builder.query(&[(
6282                "tenant_id__n",
6283                &local_var_str
6284                    .into_iter()
6285                    .map(|p| p.to_string())
6286                    .collect::<Vec<String>>()
6287                    .join(",")
6288                    .to_string(),
6289            )]),
6290        };
6291    }
6292    if let Some(ref local_var_str) = depth {
6293        local_var_req_builder =
6294            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6295    }
6296    if let Some(ref local_var_str) = exclude_m2m {
6297        local_var_req_builder =
6298            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6299    }
6300    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6301        local_var_req_builder =
6302            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6303    }
6304    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6305        let local_var_key = local_var_apikey.key.clone();
6306        let local_var_value = match local_var_apikey.prefix {
6307            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6308            None => local_var_key,
6309        };
6310        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6311    };
6312
6313    let local_var_req = local_var_req_builder.build()?;
6314    let local_var_resp = local_var_client.execute(local_var_req).await?;
6315
6316    let local_var_status = local_var_resp.status();
6317    let local_var_content = local_var_resp.text().await?;
6318
6319    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6320        serde_json::from_str(&local_var_content).map_err(Error::from)
6321    } else {
6322        let local_var_entity: Option<IpamNamespacesListError> =
6323            serde_json::from_str(&local_var_content).ok();
6324        let local_var_error = ResponseContent {
6325            status: local_var_status,
6326            content: local_var_content,
6327            entity: local_var_entity,
6328        };
6329        Err(Error::ResponseError(local_var_error))
6330    }
6331}
6332
6333/// API methods for returning or creating notes on an object.
6334pub async fn ipam_namespaces_notes_create(
6335    configuration: &configuration::Configuration,
6336    id: &str,
6337    note_input_request: crate::models::NoteInputRequest,
6338    format: Option<&str>,
6339) -> Result<crate::models::Note, Error<IpamNamespacesNotesCreateError>> {
6340    let local_var_configuration = configuration;
6341
6342    let local_var_client = &local_var_configuration.client;
6343
6344    let local_var_uri_str = format!(
6345        "{}/ipam/namespaces/{id}/notes/",
6346        local_var_configuration.base_path,
6347        id = crate::apis::urlencode(id)
6348    );
6349    let mut local_var_req_builder =
6350        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6351
6352    if let Some(ref local_var_str) = format {
6353        local_var_req_builder =
6354            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6355    }
6356    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6357        local_var_req_builder =
6358            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6359    }
6360    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6361        let local_var_key = local_var_apikey.key.clone();
6362        let local_var_value = match local_var_apikey.prefix {
6363            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6364            None => local_var_key,
6365        };
6366        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6367    };
6368    local_var_req_builder = local_var_req_builder.json(&note_input_request);
6369
6370    let local_var_req = local_var_req_builder.build()?;
6371    let local_var_resp = local_var_client.execute(local_var_req).await?;
6372
6373    let local_var_status = local_var_resp.status();
6374    let local_var_content = local_var_resp.text().await?;
6375
6376    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6377        serde_json::from_str(&local_var_content).map_err(Error::from)
6378    } else {
6379        let local_var_entity: Option<IpamNamespacesNotesCreateError> =
6380            serde_json::from_str(&local_var_content).ok();
6381        let local_var_error = ResponseContent {
6382            status: local_var_status,
6383            content: local_var_content,
6384            entity: local_var_entity,
6385        };
6386        Err(Error::ResponseError(local_var_error))
6387    }
6388}
6389
6390/// API methods for returning or creating notes on an object.
6391pub async fn ipam_namespaces_notes_list(
6392    configuration: &configuration::Configuration,
6393    id: &str,
6394    format: Option<&str>,
6395    limit: Option<i32>,
6396    offset: Option<i32>,
6397    depth: Option<i32>,
6398    exclude_m2m: Option<bool>,
6399) -> Result<crate::models::PaginatedNoteList, Error<IpamNamespacesNotesListError>> {
6400    let local_var_configuration = configuration;
6401
6402    let local_var_client = &local_var_configuration.client;
6403
6404    let local_var_uri_str = format!(
6405        "{}/ipam/namespaces/{id}/notes/",
6406        local_var_configuration.base_path,
6407        id = crate::apis::urlencode(id)
6408    );
6409    let mut local_var_req_builder =
6410        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6411
6412    if let Some(ref local_var_str) = format {
6413        local_var_req_builder =
6414            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6415    }
6416    if let Some(ref local_var_str) = limit {
6417        local_var_req_builder =
6418            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6419    }
6420    if let Some(ref local_var_str) = offset {
6421        local_var_req_builder =
6422            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6423    }
6424    if let Some(ref local_var_str) = depth {
6425        local_var_req_builder =
6426            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6427    }
6428    if let Some(ref local_var_str) = exclude_m2m {
6429        local_var_req_builder =
6430            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6431    }
6432    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6433        local_var_req_builder =
6434            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6435    }
6436    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6437        let local_var_key = local_var_apikey.key.clone();
6438        let local_var_value = match local_var_apikey.prefix {
6439            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6440            None => local_var_key,
6441        };
6442        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6443    };
6444
6445    let local_var_req = local_var_req_builder.build()?;
6446    let local_var_resp = local_var_client.execute(local_var_req).await?;
6447
6448    let local_var_status = local_var_resp.status();
6449    let local_var_content = local_var_resp.text().await?;
6450
6451    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6452        serde_json::from_str(&local_var_content).map_err(Error::from)
6453    } else {
6454        let local_var_entity: Option<IpamNamespacesNotesListError> =
6455            serde_json::from_str(&local_var_content).ok();
6456        let local_var_error = ResponseContent {
6457            status: local_var_status,
6458            content: local_var_content,
6459            entity: local_var_entity,
6460        };
6461        Err(Error::ResponseError(local_var_error))
6462    }
6463}
6464
6465/// Partial update a namespace object.
6466pub async fn ipam_namespaces_partial_update(
6467    configuration: &configuration::Configuration,
6468    id: &str,
6469    format: Option<&str>,
6470    patched_namespace_request: Option<crate::models::PatchedNamespaceRequest>,
6471) -> Result<crate::models::Namespace, Error<IpamNamespacesPartialUpdateError>> {
6472    let local_var_configuration = configuration;
6473
6474    let local_var_client = &local_var_configuration.client;
6475
6476    let local_var_uri_str = format!(
6477        "{}/ipam/namespaces/{id}/",
6478        local_var_configuration.base_path,
6479        id = crate::apis::urlencode(id)
6480    );
6481    let mut local_var_req_builder =
6482        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6483
6484    if let Some(ref local_var_str) = format {
6485        local_var_req_builder =
6486            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6487    }
6488    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6489        local_var_req_builder =
6490            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6491    }
6492    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6493        let local_var_key = local_var_apikey.key.clone();
6494        let local_var_value = match local_var_apikey.prefix {
6495            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6496            None => local_var_key,
6497        };
6498        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6499    };
6500    local_var_req_builder = local_var_req_builder.json(&patched_namespace_request);
6501
6502    let local_var_req = local_var_req_builder.build()?;
6503    let local_var_resp = local_var_client.execute(local_var_req).await?;
6504
6505    let local_var_status = local_var_resp.status();
6506    let local_var_content = local_var_resp.text().await?;
6507
6508    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6509        serde_json::from_str(&local_var_content).map_err(Error::from)
6510    } else {
6511        let local_var_entity: Option<IpamNamespacesPartialUpdateError> =
6512            serde_json::from_str(&local_var_content).ok();
6513        let local_var_error = ResponseContent {
6514            status: local_var_status,
6515            content: local_var_content,
6516            entity: local_var_entity,
6517        };
6518        Err(Error::ResponseError(local_var_error))
6519    }
6520}
6521
6522/// Retrieve a namespace object.
6523pub async fn ipam_namespaces_retrieve(
6524    configuration: &configuration::Configuration,
6525    id: &str,
6526    format: Option<&str>,
6527    depth: Option<i32>,
6528    exclude_m2m: Option<bool>,
6529) -> Result<crate::models::Namespace, Error<IpamNamespacesRetrieveError>> {
6530    let local_var_configuration = configuration;
6531
6532    let local_var_client = &local_var_configuration.client;
6533
6534    let local_var_uri_str = format!(
6535        "{}/ipam/namespaces/{id}/",
6536        local_var_configuration.base_path,
6537        id = crate::apis::urlencode(id)
6538    );
6539    let mut local_var_req_builder =
6540        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6541
6542    if let Some(ref local_var_str) = format {
6543        local_var_req_builder =
6544            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6545    }
6546    if let Some(ref local_var_str) = depth {
6547        local_var_req_builder =
6548            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6549    }
6550    if let Some(ref local_var_str) = exclude_m2m {
6551        local_var_req_builder =
6552            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6553    }
6554    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6555        local_var_req_builder =
6556            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6557    }
6558    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6559        let local_var_key = local_var_apikey.key.clone();
6560        let local_var_value = match local_var_apikey.prefix {
6561            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6562            None => local_var_key,
6563        };
6564        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6565    };
6566
6567    let local_var_req = local_var_req_builder.build()?;
6568    let local_var_resp = local_var_client.execute(local_var_req).await?;
6569
6570    let local_var_status = local_var_resp.status();
6571    let local_var_content = local_var_resp.text().await?;
6572
6573    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6574        serde_json::from_str(&local_var_content).map_err(Error::from)
6575    } else {
6576        let local_var_entity: Option<IpamNamespacesRetrieveError> =
6577            serde_json::from_str(&local_var_content).ok();
6578        let local_var_error = ResponseContent {
6579            status: local_var_status,
6580            content: local_var_content,
6581            entity: local_var_entity,
6582        };
6583        Err(Error::ResponseError(local_var_error))
6584    }
6585}
6586
6587/// Update a namespace object.
6588pub async fn ipam_namespaces_update(
6589    configuration: &configuration::Configuration,
6590    id: &str,
6591    namespace_request: crate::models::NamespaceRequest,
6592    format: Option<&str>,
6593) -> Result<crate::models::Namespace, Error<IpamNamespacesUpdateError>> {
6594    let local_var_configuration = configuration;
6595
6596    let local_var_client = &local_var_configuration.client;
6597
6598    let local_var_uri_str = format!(
6599        "{}/ipam/namespaces/{id}/",
6600        local_var_configuration.base_path,
6601        id = crate::apis::urlencode(id)
6602    );
6603    let mut local_var_req_builder =
6604        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6605
6606    if let Some(ref local_var_str) = format {
6607        local_var_req_builder =
6608            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6609    }
6610    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6611        local_var_req_builder =
6612            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6613    }
6614    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6615        let local_var_key = local_var_apikey.key.clone();
6616        let local_var_value = match local_var_apikey.prefix {
6617            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6618            None => local_var_key,
6619        };
6620        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6621    };
6622    local_var_req_builder = local_var_req_builder.json(&namespace_request);
6623
6624    let local_var_req = local_var_req_builder.build()?;
6625    let local_var_resp = local_var_client.execute(local_var_req).await?;
6626
6627    let local_var_status = local_var_resp.status();
6628    let local_var_content = local_var_resp.text().await?;
6629
6630    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6631        serde_json::from_str(&local_var_content).map_err(Error::from)
6632    } else {
6633        let local_var_entity: Option<IpamNamespacesUpdateError> =
6634            serde_json::from_str(&local_var_content).ok();
6635        let local_var_error = ResponseContent {
6636            status: local_var_status,
6637            content: local_var_content,
6638            entity: local_var_entity,
6639        };
6640        Err(Error::ResponseError(local_var_error))
6641    }
6642}
6643
6644/// Destroy a list of prefix location assignment objects.
6645pub async fn ipam_prefix_location_assignments_bulk_destroy(
6646    configuration: &configuration::Configuration,
6647    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
6648    format: Option<&str>,
6649) -> Result<(), Error<IpamPrefixLocationAssignmentsBulkDestroyError>> {
6650    let local_var_configuration = configuration;
6651
6652    let local_var_client = &local_var_configuration.client;
6653
6654    let local_var_uri_str = format!(
6655        "{}/ipam/prefix-location-assignments/",
6656        local_var_configuration.base_path
6657    );
6658    let mut local_var_req_builder =
6659        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6660
6661    if let Some(ref local_var_str) = format {
6662        local_var_req_builder =
6663            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6664    }
6665    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6666        local_var_req_builder =
6667            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6668    }
6669    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6670        let local_var_key = local_var_apikey.key.clone();
6671        let local_var_value = match local_var_apikey.prefix {
6672            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6673            None => local_var_key,
6674        };
6675        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6676    };
6677    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
6678
6679    let local_var_req = local_var_req_builder.build()?;
6680    let local_var_resp = local_var_client.execute(local_var_req).await?;
6681
6682    let local_var_status = local_var_resp.status();
6683    let local_var_content = local_var_resp.text().await?;
6684
6685    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6686        Ok(())
6687    } else {
6688        let local_var_entity: Option<IpamPrefixLocationAssignmentsBulkDestroyError> =
6689            serde_json::from_str(&local_var_content).ok();
6690        let local_var_error = ResponseContent {
6691            status: local_var_status,
6692            content: local_var_content,
6693            entity: local_var_entity,
6694        };
6695        Err(Error::ResponseError(local_var_error))
6696    }
6697}
6698
6699/// Partial update a list of prefix location assignment objects.
6700pub async fn ipam_prefix_location_assignments_bulk_partial_update(
6701    configuration: &configuration::Configuration,
6702    patched_bulk_writable_prefix_location_assignment_request: Vec<
6703        crate::models::PatchedBulkWritablePrefixLocationAssignmentRequest,
6704    >,
6705    format: Option<&str>,
6706) -> Result<
6707    Vec<crate::models::PrefixLocationAssignment>,
6708    Error<IpamPrefixLocationAssignmentsBulkPartialUpdateError>,
6709> {
6710    let local_var_configuration = configuration;
6711
6712    let local_var_client = &local_var_configuration.client;
6713
6714    let local_var_uri_str = format!(
6715        "{}/ipam/prefix-location-assignments/",
6716        local_var_configuration.base_path
6717    );
6718    let mut local_var_req_builder =
6719        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6720
6721    if let Some(ref local_var_str) = format {
6722        local_var_req_builder =
6723            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6724    }
6725    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6726        local_var_req_builder =
6727            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6728    }
6729    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6730        let local_var_key = local_var_apikey.key.clone();
6731        let local_var_value = match local_var_apikey.prefix {
6732            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6733            None => local_var_key,
6734        };
6735        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6736    };
6737    local_var_req_builder =
6738        local_var_req_builder.json(&patched_bulk_writable_prefix_location_assignment_request);
6739
6740    let local_var_req = local_var_req_builder.build()?;
6741    let local_var_resp = local_var_client.execute(local_var_req).await?;
6742
6743    let local_var_status = local_var_resp.status();
6744    let local_var_content = local_var_resp.text().await?;
6745
6746    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6747        serde_json::from_str(&local_var_content).map_err(Error::from)
6748    } else {
6749        let local_var_entity: Option<IpamPrefixLocationAssignmentsBulkPartialUpdateError> =
6750            serde_json::from_str(&local_var_content).ok();
6751        let local_var_error = ResponseContent {
6752            status: local_var_status,
6753            content: local_var_content,
6754            entity: local_var_entity,
6755        };
6756        Err(Error::ResponseError(local_var_error))
6757    }
6758}
6759
6760/// Update a list of prefix location assignment objects.
6761pub async fn ipam_prefix_location_assignments_bulk_update(
6762    configuration: &configuration::Configuration,
6763    bulk_writable_prefix_location_assignment_request: Vec<
6764        crate::models::BulkWritablePrefixLocationAssignmentRequest,
6765    >,
6766    format: Option<&str>,
6767) -> Result<
6768    Vec<crate::models::PrefixLocationAssignment>,
6769    Error<IpamPrefixLocationAssignmentsBulkUpdateError>,
6770> {
6771    let local_var_configuration = configuration;
6772
6773    let local_var_client = &local_var_configuration.client;
6774
6775    let local_var_uri_str = format!(
6776        "{}/ipam/prefix-location-assignments/",
6777        local_var_configuration.base_path
6778    );
6779    let mut local_var_req_builder =
6780        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6781
6782    if let Some(ref local_var_str) = format {
6783        local_var_req_builder =
6784            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6785    }
6786    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6787        local_var_req_builder =
6788            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6789    }
6790    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6791        let local_var_key = local_var_apikey.key.clone();
6792        let local_var_value = match local_var_apikey.prefix {
6793            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6794            None => local_var_key,
6795        };
6796        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6797    };
6798    local_var_req_builder =
6799        local_var_req_builder.json(&bulk_writable_prefix_location_assignment_request);
6800
6801    let local_var_req = local_var_req_builder.build()?;
6802    let local_var_resp = local_var_client.execute(local_var_req).await?;
6803
6804    let local_var_status = local_var_resp.status();
6805    let local_var_content = local_var_resp.text().await?;
6806
6807    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6808        serde_json::from_str(&local_var_content).map_err(Error::from)
6809    } else {
6810        let local_var_entity: Option<IpamPrefixLocationAssignmentsBulkUpdateError> =
6811            serde_json::from_str(&local_var_content).ok();
6812        let local_var_error = ResponseContent {
6813            status: local_var_status,
6814            content: local_var_content,
6815            entity: local_var_entity,
6816        };
6817        Err(Error::ResponseError(local_var_error))
6818    }
6819}
6820
6821/// Create one or more prefix location assignment objects.
6822pub async fn ipam_prefix_location_assignments_create(
6823    configuration: &configuration::Configuration,
6824    prefix_location_assignment_request: crate::models::PrefixLocationAssignmentRequest,
6825    format: Option<&str>,
6826) -> Result<crate::models::PrefixLocationAssignment, Error<IpamPrefixLocationAssignmentsCreateError>>
6827{
6828    let local_var_configuration = configuration;
6829
6830    let local_var_client = &local_var_configuration.client;
6831
6832    let local_var_uri_str = format!(
6833        "{}/ipam/prefix-location-assignments/",
6834        local_var_configuration.base_path
6835    );
6836    let mut local_var_req_builder =
6837        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6838
6839    if let Some(ref local_var_str) = format {
6840        local_var_req_builder =
6841            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6842    }
6843    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6844        local_var_req_builder =
6845            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6846    }
6847    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6848        let local_var_key = local_var_apikey.key.clone();
6849        let local_var_value = match local_var_apikey.prefix {
6850            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6851            None => local_var_key,
6852        };
6853        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6854    };
6855    local_var_req_builder = local_var_req_builder.json(&prefix_location_assignment_request);
6856
6857    let local_var_req = local_var_req_builder.build()?;
6858    let local_var_resp = local_var_client.execute(local_var_req).await?;
6859
6860    let local_var_status = local_var_resp.status();
6861    let local_var_content = local_var_resp.text().await?;
6862
6863    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6864        serde_json::from_str(&local_var_content).map_err(Error::from)
6865    } else {
6866        let local_var_entity: Option<IpamPrefixLocationAssignmentsCreateError> =
6867            serde_json::from_str(&local_var_content).ok();
6868        let local_var_error = ResponseContent {
6869            status: local_var_status,
6870            content: local_var_content,
6871            entity: local_var_entity,
6872        };
6873        Err(Error::ResponseError(local_var_error))
6874    }
6875}
6876
6877/// Destroy a prefix location assignment object.
6878pub async fn ipam_prefix_location_assignments_destroy(
6879    configuration: &configuration::Configuration,
6880    id: &str,
6881    format: Option<&str>,
6882) -> Result<(), Error<IpamPrefixLocationAssignmentsDestroyError>> {
6883    let local_var_configuration = configuration;
6884
6885    let local_var_client = &local_var_configuration.client;
6886
6887    let local_var_uri_str = format!(
6888        "{}/ipam/prefix-location-assignments/{id}/",
6889        local_var_configuration.base_path,
6890        id = crate::apis::urlencode(id)
6891    );
6892    let mut local_var_req_builder =
6893        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6894
6895    if let Some(ref local_var_str) = format {
6896        local_var_req_builder =
6897            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6898    }
6899    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6900        local_var_req_builder =
6901            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6902    }
6903    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6904        let local_var_key = local_var_apikey.key.clone();
6905        let local_var_value = match local_var_apikey.prefix {
6906            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6907            None => local_var_key,
6908        };
6909        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6910    };
6911
6912    let local_var_req = local_var_req_builder.build()?;
6913    let local_var_resp = local_var_client.execute(local_var_req).await?;
6914
6915    let local_var_status = local_var_resp.status();
6916    let local_var_content = local_var_resp.text().await?;
6917
6918    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6919        Ok(())
6920    } else {
6921        let local_var_entity: Option<IpamPrefixLocationAssignmentsDestroyError> =
6922            serde_json::from_str(&local_var_content).ok();
6923        let local_var_error = ResponseContent {
6924            status: local_var_status,
6925            content: local_var_content,
6926            entity: local_var_entity,
6927        };
6928        Err(Error::ResponseError(local_var_error))
6929    }
6930}
6931
6932/// Retrieve a list of prefix location assignment objects.
6933pub async fn ipam_prefix_location_assignments_list(
6934    configuration: &configuration::Configuration,
6935    created: Option<Vec<String>>,
6936    format: Option<&str>,
6937    id: Option<Vec<uuid::Uuid>>,
6938    id__n: Option<Vec<uuid::Uuid>>,
6939    last_updated: Option<Vec<String>>,
6940    limit: Option<i32>,
6941    location: Option<Vec<String>>,
6942    location__n: Option<Vec<String>>,
6943    offset: Option<i32>,
6944    prefix: Option<Vec<String>>,
6945    prefix__n: Option<Vec<String>>,
6946    q: Option<&str>,
6947    sort: Option<&str>,
6948    depth: Option<i32>,
6949    exclude_m2m: Option<bool>,
6950) -> Result<
6951    crate::models::PaginatedPrefixLocationAssignmentList,
6952    Error<IpamPrefixLocationAssignmentsListError>,
6953> {
6954    let local_var_configuration = configuration;
6955
6956    let local_var_client = &local_var_configuration.client;
6957
6958    let local_var_uri_str = format!(
6959        "{}/ipam/prefix-location-assignments/",
6960        local_var_configuration.base_path
6961    );
6962    let mut local_var_req_builder =
6963        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6964
6965    if let Some(ref local_var_str) = created {
6966        local_var_req_builder = match "multi" {
6967            "multi" => local_var_req_builder.query(
6968                &local_var_str
6969                    .into_iter()
6970                    .map(|p| ("created".to_owned(), p.to_string()))
6971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6972            ),
6973            _ => local_var_req_builder.query(&[(
6974                "created",
6975                &local_var_str
6976                    .into_iter()
6977                    .map(|p| p.to_string())
6978                    .collect::<Vec<String>>()
6979                    .join(",")
6980                    .to_string(),
6981            )]),
6982        };
6983    }
6984    if let Some(ref local_var_str) = format {
6985        local_var_req_builder =
6986            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6987    }
6988    if let Some(ref local_var_str) = id {
6989        local_var_req_builder = match "multi" {
6990            "multi" => local_var_req_builder.query(
6991                &local_var_str
6992                    .into_iter()
6993                    .map(|p| ("id".to_owned(), p.to_string()))
6994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6995            ),
6996            _ => local_var_req_builder.query(&[(
6997                "id",
6998                &local_var_str
6999                    .into_iter()
7000                    .map(|p| p.to_string())
7001                    .collect::<Vec<String>>()
7002                    .join(",")
7003                    .to_string(),
7004            )]),
7005        };
7006    }
7007    if let Some(ref local_var_str) = id__n {
7008        local_var_req_builder = match "multi" {
7009            "multi" => local_var_req_builder.query(
7010                &local_var_str
7011                    .into_iter()
7012                    .map(|p| ("id__n".to_owned(), p.to_string()))
7013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7014            ),
7015            _ => local_var_req_builder.query(&[(
7016                "id__n",
7017                &local_var_str
7018                    .into_iter()
7019                    .map(|p| p.to_string())
7020                    .collect::<Vec<String>>()
7021                    .join(",")
7022                    .to_string(),
7023            )]),
7024        };
7025    }
7026    if let Some(ref local_var_str) = last_updated {
7027        local_var_req_builder = match "multi" {
7028            "multi" => local_var_req_builder.query(
7029                &local_var_str
7030                    .into_iter()
7031                    .map(|p| ("last_updated".to_owned(), p.to_string()))
7032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7033            ),
7034            _ => local_var_req_builder.query(&[(
7035                "last_updated",
7036                &local_var_str
7037                    .into_iter()
7038                    .map(|p| p.to_string())
7039                    .collect::<Vec<String>>()
7040                    .join(",")
7041                    .to_string(),
7042            )]),
7043        };
7044    }
7045    if let Some(ref local_var_str) = limit {
7046        local_var_req_builder =
7047            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7048    }
7049    if let Some(ref local_var_str) = location {
7050        local_var_req_builder = match "multi" {
7051            "multi" => local_var_req_builder.query(
7052                &local_var_str
7053                    .into_iter()
7054                    .map(|p| ("location".to_owned(), p.to_string()))
7055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7056            ),
7057            _ => local_var_req_builder.query(&[(
7058                "location",
7059                &local_var_str
7060                    .into_iter()
7061                    .map(|p| p.to_string())
7062                    .collect::<Vec<String>>()
7063                    .join(",")
7064                    .to_string(),
7065            )]),
7066        };
7067    }
7068    if let Some(ref local_var_str) = location__n {
7069        local_var_req_builder = match "multi" {
7070            "multi" => local_var_req_builder.query(
7071                &local_var_str
7072                    .into_iter()
7073                    .map(|p| ("location__n".to_owned(), p.to_string()))
7074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7075            ),
7076            _ => local_var_req_builder.query(&[(
7077                "location__n",
7078                &local_var_str
7079                    .into_iter()
7080                    .map(|p| p.to_string())
7081                    .collect::<Vec<String>>()
7082                    .join(",")
7083                    .to_string(),
7084            )]),
7085        };
7086    }
7087    if let Some(ref local_var_str) = offset {
7088        local_var_req_builder =
7089            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7090    }
7091    if let Some(ref local_var_str) = prefix {
7092        local_var_req_builder = match "multi" {
7093            "multi" => local_var_req_builder.query(
7094                &local_var_str
7095                    .into_iter()
7096                    .map(|p| ("prefix".to_owned(), p.to_string()))
7097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7098            ),
7099            _ => local_var_req_builder.query(&[(
7100                "prefix",
7101                &local_var_str
7102                    .into_iter()
7103                    .map(|p| p.to_string())
7104                    .collect::<Vec<String>>()
7105                    .join(",")
7106                    .to_string(),
7107            )]),
7108        };
7109    }
7110    if let Some(ref local_var_str) = prefix__n {
7111        local_var_req_builder = match "multi" {
7112            "multi" => local_var_req_builder.query(
7113                &local_var_str
7114                    .into_iter()
7115                    .map(|p| ("prefix__n".to_owned(), p.to_string()))
7116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7117            ),
7118            _ => local_var_req_builder.query(&[(
7119                "prefix__n",
7120                &local_var_str
7121                    .into_iter()
7122                    .map(|p| p.to_string())
7123                    .collect::<Vec<String>>()
7124                    .join(",")
7125                    .to_string(),
7126            )]),
7127        };
7128    }
7129    if let Some(ref local_var_str) = q {
7130        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
7131    }
7132    if let Some(ref local_var_str) = sort {
7133        local_var_req_builder =
7134            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
7135    }
7136    if let Some(ref local_var_str) = depth {
7137        local_var_req_builder =
7138            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7139    }
7140    if let Some(ref local_var_str) = exclude_m2m {
7141        local_var_req_builder =
7142            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7143    }
7144    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7145        local_var_req_builder =
7146            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7147    }
7148    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7149        let local_var_key = local_var_apikey.key.clone();
7150        let local_var_value = match local_var_apikey.prefix {
7151            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7152            None => local_var_key,
7153        };
7154        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7155    };
7156
7157    let local_var_req = local_var_req_builder.build()?;
7158    let local_var_resp = local_var_client.execute(local_var_req).await?;
7159
7160    let local_var_status = local_var_resp.status();
7161    let local_var_content = local_var_resp.text().await?;
7162
7163    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7164        serde_json::from_str(&local_var_content).map_err(Error::from)
7165    } else {
7166        let local_var_entity: Option<IpamPrefixLocationAssignmentsListError> =
7167            serde_json::from_str(&local_var_content).ok();
7168        let local_var_error = ResponseContent {
7169            status: local_var_status,
7170            content: local_var_content,
7171            entity: local_var_entity,
7172        };
7173        Err(Error::ResponseError(local_var_error))
7174    }
7175}
7176
7177/// Partial update a prefix location assignment object.
7178pub async fn ipam_prefix_location_assignments_partial_update(
7179    configuration: &configuration::Configuration,
7180    id: &str,
7181    format: Option<&str>,
7182    patched_prefix_location_assignment_request: Option<
7183        crate::models::PatchedPrefixLocationAssignmentRequest,
7184    >,
7185) -> Result<
7186    crate::models::PrefixLocationAssignment,
7187    Error<IpamPrefixLocationAssignmentsPartialUpdateError>,
7188> {
7189    let local_var_configuration = configuration;
7190
7191    let local_var_client = &local_var_configuration.client;
7192
7193    let local_var_uri_str = format!(
7194        "{}/ipam/prefix-location-assignments/{id}/",
7195        local_var_configuration.base_path,
7196        id = crate::apis::urlencode(id)
7197    );
7198    let mut local_var_req_builder =
7199        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7200
7201    if let Some(ref local_var_str) = format {
7202        local_var_req_builder =
7203            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7204    }
7205    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7206        local_var_req_builder =
7207            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7208    }
7209    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7210        let local_var_key = local_var_apikey.key.clone();
7211        let local_var_value = match local_var_apikey.prefix {
7212            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7213            None => local_var_key,
7214        };
7215        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7216    };
7217    local_var_req_builder = local_var_req_builder.json(&patched_prefix_location_assignment_request);
7218
7219    let local_var_req = local_var_req_builder.build()?;
7220    let local_var_resp = local_var_client.execute(local_var_req).await?;
7221
7222    let local_var_status = local_var_resp.status();
7223    let local_var_content = local_var_resp.text().await?;
7224
7225    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7226        serde_json::from_str(&local_var_content).map_err(Error::from)
7227    } else {
7228        let local_var_entity: Option<IpamPrefixLocationAssignmentsPartialUpdateError> =
7229            serde_json::from_str(&local_var_content).ok();
7230        let local_var_error = ResponseContent {
7231            status: local_var_status,
7232            content: local_var_content,
7233            entity: local_var_entity,
7234        };
7235        Err(Error::ResponseError(local_var_error))
7236    }
7237}
7238
7239/// Retrieve a prefix location assignment object.
7240pub async fn ipam_prefix_location_assignments_retrieve(
7241    configuration: &configuration::Configuration,
7242    id: &str,
7243    format: Option<&str>,
7244    depth: Option<i32>,
7245    exclude_m2m: Option<bool>,
7246) -> Result<
7247    crate::models::PrefixLocationAssignment,
7248    Error<IpamPrefixLocationAssignmentsRetrieveError>,
7249> {
7250    let local_var_configuration = configuration;
7251
7252    let local_var_client = &local_var_configuration.client;
7253
7254    let local_var_uri_str = format!(
7255        "{}/ipam/prefix-location-assignments/{id}/",
7256        local_var_configuration.base_path,
7257        id = crate::apis::urlencode(id)
7258    );
7259    let mut local_var_req_builder =
7260        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7261
7262    if let Some(ref local_var_str) = format {
7263        local_var_req_builder =
7264            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7265    }
7266    if let Some(ref local_var_str) = depth {
7267        local_var_req_builder =
7268            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7269    }
7270    if let Some(ref local_var_str) = exclude_m2m {
7271        local_var_req_builder =
7272            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7273    }
7274    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7275        local_var_req_builder =
7276            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7277    }
7278    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7279        let local_var_key = local_var_apikey.key.clone();
7280        let local_var_value = match local_var_apikey.prefix {
7281            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7282            None => local_var_key,
7283        };
7284        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7285    };
7286
7287    let local_var_req = local_var_req_builder.build()?;
7288    let local_var_resp = local_var_client.execute(local_var_req).await?;
7289
7290    let local_var_status = local_var_resp.status();
7291    let local_var_content = local_var_resp.text().await?;
7292
7293    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7294        serde_json::from_str(&local_var_content).map_err(Error::from)
7295    } else {
7296        let local_var_entity: Option<IpamPrefixLocationAssignmentsRetrieveError> =
7297            serde_json::from_str(&local_var_content).ok();
7298        let local_var_error = ResponseContent {
7299            status: local_var_status,
7300            content: local_var_content,
7301            entity: local_var_entity,
7302        };
7303        Err(Error::ResponseError(local_var_error))
7304    }
7305}
7306
7307/// Update a prefix location assignment object.
7308pub async fn ipam_prefix_location_assignments_update(
7309    configuration: &configuration::Configuration,
7310    id: &str,
7311    prefix_location_assignment_request: crate::models::PrefixLocationAssignmentRequest,
7312    format: Option<&str>,
7313) -> Result<crate::models::PrefixLocationAssignment, Error<IpamPrefixLocationAssignmentsUpdateError>>
7314{
7315    let local_var_configuration = configuration;
7316
7317    let local_var_client = &local_var_configuration.client;
7318
7319    let local_var_uri_str = format!(
7320        "{}/ipam/prefix-location-assignments/{id}/",
7321        local_var_configuration.base_path,
7322        id = crate::apis::urlencode(id)
7323    );
7324    let mut local_var_req_builder =
7325        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7326
7327    if let Some(ref local_var_str) = format {
7328        local_var_req_builder =
7329            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7330    }
7331    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7332        local_var_req_builder =
7333            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7334    }
7335    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7336        let local_var_key = local_var_apikey.key.clone();
7337        let local_var_value = match local_var_apikey.prefix {
7338            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7339            None => local_var_key,
7340        };
7341        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7342    };
7343    local_var_req_builder = local_var_req_builder.json(&prefix_location_assignment_request);
7344
7345    let local_var_req = local_var_req_builder.build()?;
7346    let local_var_resp = local_var_client.execute(local_var_req).await?;
7347
7348    let local_var_status = local_var_resp.status();
7349    let local_var_content = local_var_resp.text().await?;
7350
7351    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7352        serde_json::from_str(&local_var_content).map_err(Error::from)
7353    } else {
7354        let local_var_entity: Option<IpamPrefixLocationAssignmentsUpdateError> =
7355            serde_json::from_str(&local_var_content).ok();
7356        let local_var_error = ResponseContent {
7357            status: local_var_status,
7358            content: local_var_content,
7359            entity: local_var_entity,
7360        };
7361        Err(Error::ResponseError(local_var_error))
7362    }
7363}
7364
7365/// A convenience method for listing and/or allocating available IP addresses within a prefix.  By default, the number of IPs returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.  This uses a Redis lock to prevent this API from being invoked in parallel, in order to avoid a race condition if multiple clients tried to simultaneously request allocation from the same parent prefix.
7366pub async fn ipam_prefixes_available_ips_create(
7367    configuration: &configuration::Configuration,
7368    id: &str,
7369    ip_allocation_request: Vec<crate::models::IpAllocationRequest>,
7370    format: Option<&str>,
7371    limit: Option<i32>,
7372    offset: Option<i32>,
7373    range_end: Option<&str>,
7374    range_start: Option<&str>,
7375    sort: Option<&str>,
7376) -> Result<crate::models::PaginatedIpAddressList, Error<IpamPrefixesAvailableIpsCreateError>> {
7377    let local_var_configuration = configuration;
7378
7379    let local_var_client = &local_var_configuration.client;
7380
7381    let local_var_uri_str = format!(
7382        "{}/ipam/prefixes/{id}/available-ips/",
7383        local_var_configuration.base_path,
7384        id = crate::apis::urlencode(id)
7385    );
7386    let mut local_var_req_builder =
7387        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7388
7389    if let Some(ref local_var_str) = format {
7390        local_var_req_builder =
7391            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7392    }
7393    if let Some(ref local_var_str) = limit {
7394        local_var_req_builder =
7395            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7396    }
7397    if let Some(ref local_var_str) = offset {
7398        local_var_req_builder =
7399            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7400    }
7401    if let Some(ref local_var_str) = range_end {
7402        local_var_req_builder =
7403            local_var_req_builder.query(&[("range_end", &local_var_str.to_string())]);
7404    }
7405    if let Some(ref local_var_str) = range_start {
7406        local_var_req_builder =
7407            local_var_req_builder.query(&[("range_start", &local_var_str.to_string())]);
7408    }
7409    if let Some(ref local_var_str) = sort {
7410        local_var_req_builder =
7411            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
7412    }
7413    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7414        local_var_req_builder =
7415            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7416    }
7417    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7418        let local_var_key = local_var_apikey.key.clone();
7419        let local_var_value = match local_var_apikey.prefix {
7420            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7421            None => local_var_key,
7422        };
7423        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7424    };
7425    local_var_req_builder = local_var_req_builder.json(&ip_allocation_request);
7426
7427    let local_var_req = local_var_req_builder.build()?;
7428    let local_var_resp = local_var_client.execute(local_var_req).await?;
7429
7430    let local_var_status = local_var_resp.status();
7431    let local_var_content = local_var_resp.text().await?;
7432
7433    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7434        serde_json::from_str(&local_var_content).map_err(Error::from)
7435    } else {
7436        let local_var_entity: Option<IpamPrefixesAvailableIpsCreateError> =
7437            serde_json::from_str(&local_var_content).ok();
7438        let local_var_error = ResponseContent {
7439            status: local_var_status,
7440            content: local_var_content,
7441            entity: local_var_entity,
7442        };
7443        Err(Error::ResponseError(local_var_error))
7444    }
7445}
7446
7447/// A convenience method for listing and/or allocating available IP addresses within a prefix.  By default, the number of IPs returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.  This uses a Redis lock to prevent this API from being invoked in parallel, in order to avoid a race condition if multiple clients tried to simultaneously request allocation from the same parent prefix.
7448pub async fn ipam_prefixes_available_ips_list(
7449    configuration: &configuration::Configuration,
7450    id: &str,
7451    format: Option<&str>,
7452    limit: Option<i32>,
7453    offset: Option<i32>,
7454    range_end: Option<&str>,
7455    range_start: Option<&str>,
7456    sort: Option<&str>,
7457    depth: Option<i32>,
7458    exclude_m2m: Option<bool>,
7459) -> Result<crate::models::PaginatedAvailableIpList, Error<IpamPrefixesAvailableIpsListError>> {
7460    let local_var_configuration = configuration;
7461
7462    let local_var_client = &local_var_configuration.client;
7463
7464    let local_var_uri_str = format!(
7465        "{}/ipam/prefixes/{id}/available-ips/",
7466        local_var_configuration.base_path,
7467        id = crate::apis::urlencode(id)
7468    );
7469    let mut local_var_req_builder =
7470        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7471
7472    if let Some(ref local_var_str) = format {
7473        local_var_req_builder =
7474            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7475    }
7476    if let Some(ref local_var_str) = limit {
7477        local_var_req_builder =
7478            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7479    }
7480    if let Some(ref local_var_str) = offset {
7481        local_var_req_builder =
7482            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7483    }
7484    if let Some(ref local_var_str) = range_end {
7485        local_var_req_builder =
7486            local_var_req_builder.query(&[("range_end", &local_var_str.to_string())]);
7487    }
7488    if let Some(ref local_var_str) = range_start {
7489        local_var_req_builder =
7490            local_var_req_builder.query(&[("range_start", &local_var_str.to_string())]);
7491    }
7492    if let Some(ref local_var_str) = sort {
7493        local_var_req_builder =
7494            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
7495    }
7496    if let Some(ref local_var_str) = depth {
7497        local_var_req_builder =
7498            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7499    }
7500    if let Some(ref local_var_str) = exclude_m2m {
7501        local_var_req_builder =
7502            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7503    }
7504    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7505        local_var_req_builder =
7506            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7507    }
7508    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7509        let local_var_key = local_var_apikey.key.clone();
7510        let local_var_value = match local_var_apikey.prefix {
7511            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7512            None => local_var_key,
7513        };
7514        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7515    };
7516
7517    let local_var_req = local_var_req_builder.build()?;
7518    let local_var_resp = local_var_client.execute(local_var_req).await?;
7519
7520    let local_var_status = local_var_resp.status();
7521    let local_var_content = local_var_resp.text().await?;
7522
7523    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7524        serde_json::from_str(&local_var_content).map_err(Error::from)
7525    } else {
7526        let local_var_entity: Option<IpamPrefixesAvailableIpsListError> =
7527            serde_json::from_str(&local_var_content).ok();
7528        let local_var_error = ResponseContent {
7529            status: local_var_status,
7530            content: local_var_content,
7531            entity: local_var_entity,
7532        };
7533        Err(Error::ResponseError(local_var_error))
7534    }
7535}
7536
7537/// A convenience method for listing and/or allocating available child prefixes within a parent.  This uses a Redis lock to prevent this API from being invoked in parallel, in order to avoid a race condition if multiple clients tried to simultaneously request allocation from the same parent prefix.
7538pub async fn ipam_prefixes_available_prefixes_create(
7539    configuration: &configuration::Configuration,
7540    id: &str,
7541    prefix_length_request: crate::models::PrefixLengthRequest,
7542    format: Option<&str>,
7543    limit: Option<i32>,
7544    offset: Option<i32>,
7545    sort: Option<&str>,
7546) -> Result<crate::models::PaginatedPrefixList, Error<IpamPrefixesAvailablePrefixesCreateError>> {
7547    let local_var_configuration = configuration;
7548
7549    let local_var_client = &local_var_configuration.client;
7550
7551    let local_var_uri_str = format!(
7552        "{}/ipam/prefixes/{id}/available-prefixes/",
7553        local_var_configuration.base_path,
7554        id = crate::apis::urlencode(id)
7555    );
7556    let mut local_var_req_builder =
7557        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7558
7559    if let Some(ref local_var_str) = format {
7560        local_var_req_builder =
7561            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7562    }
7563    if let Some(ref local_var_str) = limit {
7564        local_var_req_builder =
7565            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7566    }
7567    if let Some(ref local_var_str) = offset {
7568        local_var_req_builder =
7569            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7570    }
7571    if let Some(ref local_var_str) = sort {
7572        local_var_req_builder =
7573            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
7574    }
7575    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7576        local_var_req_builder =
7577            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7578    }
7579    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7580        let local_var_key = local_var_apikey.key.clone();
7581        let local_var_value = match local_var_apikey.prefix {
7582            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7583            None => local_var_key,
7584        };
7585        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7586    };
7587    local_var_req_builder = local_var_req_builder.json(&prefix_length_request);
7588
7589    let local_var_req = local_var_req_builder.build()?;
7590    let local_var_resp = local_var_client.execute(local_var_req).await?;
7591
7592    let local_var_status = local_var_resp.status();
7593    let local_var_content = local_var_resp.text().await?;
7594
7595    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7596        serde_json::from_str(&local_var_content).map_err(Error::from)
7597    } else {
7598        let local_var_entity: Option<IpamPrefixesAvailablePrefixesCreateError> =
7599            serde_json::from_str(&local_var_content).ok();
7600        let local_var_error = ResponseContent {
7601            status: local_var_status,
7602            content: local_var_content,
7603            entity: local_var_entity,
7604        };
7605        Err(Error::ResponseError(local_var_error))
7606    }
7607}
7608
7609/// A convenience method for listing and/or allocating available child prefixes within a parent.  This uses a Redis lock to prevent this API from being invoked in parallel, in order to avoid a race condition if multiple clients tried to simultaneously request allocation from the same parent prefix.
7610pub async fn ipam_prefixes_available_prefixes_list(
7611    configuration: &configuration::Configuration,
7612    id: &str,
7613    format: Option<&str>,
7614    limit: Option<i32>,
7615    offset: Option<i32>,
7616    sort: Option<&str>,
7617    depth: Option<i32>,
7618    exclude_m2m: Option<bool>,
7619) -> Result<
7620    crate::models::PaginatedAvailablePrefixList,
7621    Error<IpamPrefixesAvailablePrefixesListError>,
7622> {
7623    let local_var_configuration = configuration;
7624
7625    let local_var_client = &local_var_configuration.client;
7626
7627    let local_var_uri_str = format!(
7628        "{}/ipam/prefixes/{id}/available-prefixes/",
7629        local_var_configuration.base_path,
7630        id = crate::apis::urlencode(id)
7631    );
7632    let mut local_var_req_builder =
7633        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7634
7635    if let Some(ref local_var_str) = format {
7636        local_var_req_builder =
7637            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7638    }
7639    if let Some(ref local_var_str) = limit {
7640        local_var_req_builder =
7641            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7642    }
7643    if let Some(ref local_var_str) = offset {
7644        local_var_req_builder =
7645            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7646    }
7647    if let Some(ref local_var_str) = sort {
7648        local_var_req_builder =
7649            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
7650    }
7651    if let Some(ref local_var_str) = depth {
7652        local_var_req_builder =
7653            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7654    }
7655    if let Some(ref local_var_str) = exclude_m2m {
7656        local_var_req_builder =
7657            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7658    }
7659    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7660        local_var_req_builder =
7661            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7662    }
7663    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7664        let local_var_key = local_var_apikey.key.clone();
7665        let local_var_value = match local_var_apikey.prefix {
7666            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7667            None => local_var_key,
7668        };
7669        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7670    };
7671
7672    let local_var_req = local_var_req_builder.build()?;
7673    let local_var_resp = local_var_client.execute(local_var_req).await?;
7674
7675    let local_var_status = local_var_resp.status();
7676    let local_var_content = local_var_resp.text().await?;
7677
7678    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7679        serde_json::from_str(&local_var_content).map_err(Error::from)
7680    } else {
7681        let local_var_entity: Option<IpamPrefixesAvailablePrefixesListError> =
7682            serde_json::from_str(&local_var_content).ok();
7683        let local_var_error = ResponseContent {
7684            status: local_var_status,
7685            content: local_var_content,
7686            entity: local_var_entity,
7687        };
7688        Err(Error::ResponseError(local_var_error))
7689    }
7690}
7691
7692/// Destroy a list of prefix objects.
7693pub async fn ipam_prefixes_bulk_destroy(
7694    configuration: &configuration::Configuration,
7695    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
7696    format: Option<&str>,
7697) -> Result<(), Error<IpamPrefixesBulkDestroyError>> {
7698    let local_var_configuration = configuration;
7699
7700    let local_var_client = &local_var_configuration.client;
7701
7702    let local_var_uri_str = format!("{}/ipam/prefixes/", local_var_configuration.base_path);
7703    let mut local_var_req_builder =
7704        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7705
7706    if let Some(ref local_var_str) = format {
7707        local_var_req_builder =
7708            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7709    }
7710    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7711        local_var_req_builder =
7712            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7713    }
7714    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7715        let local_var_key = local_var_apikey.key.clone();
7716        let local_var_value = match local_var_apikey.prefix {
7717            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7718            None => local_var_key,
7719        };
7720        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7721    };
7722    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
7723
7724    let local_var_req = local_var_req_builder.build()?;
7725    let local_var_resp = local_var_client.execute(local_var_req).await?;
7726
7727    let local_var_status = local_var_resp.status();
7728    let local_var_content = local_var_resp.text().await?;
7729
7730    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7731        Ok(())
7732    } else {
7733        let local_var_entity: Option<IpamPrefixesBulkDestroyError> =
7734            serde_json::from_str(&local_var_content).ok();
7735        let local_var_error = ResponseContent {
7736            status: local_var_status,
7737            content: local_var_content,
7738            entity: local_var_entity,
7739        };
7740        Err(Error::ResponseError(local_var_error))
7741    }
7742}
7743
7744/// Partial update a list of prefix objects.
7745pub async fn ipam_prefixes_bulk_partial_update(
7746    configuration: &configuration::Configuration,
7747    patched_bulk_writable_prefix_request: Vec<crate::models::PatchedBulkWritablePrefixRequest>,
7748    format: Option<&str>,
7749) -> Result<Vec<crate::models::Prefix>, Error<IpamPrefixesBulkPartialUpdateError>> {
7750    let local_var_configuration = configuration;
7751
7752    let local_var_client = &local_var_configuration.client;
7753
7754    let local_var_uri_str = format!("{}/ipam/prefixes/", local_var_configuration.base_path);
7755    let mut local_var_req_builder =
7756        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7757
7758    if let Some(ref local_var_str) = format {
7759        local_var_req_builder =
7760            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7761    }
7762    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7763        local_var_req_builder =
7764            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7765    }
7766    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7767        let local_var_key = local_var_apikey.key.clone();
7768        let local_var_value = match local_var_apikey.prefix {
7769            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7770            None => local_var_key,
7771        };
7772        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7773    };
7774    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_prefix_request);
7775
7776    let local_var_req = local_var_req_builder.build()?;
7777    let local_var_resp = local_var_client.execute(local_var_req).await?;
7778
7779    let local_var_status = local_var_resp.status();
7780    let local_var_content = local_var_resp.text().await?;
7781
7782    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7783        serde_json::from_str(&local_var_content).map_err(Error::from)
7784    } else {
7785        let local_var_entity: Option<IpamPrefixesBulkPartialUpdateError> =
7786            serde_json::from_str(&local_var_content).ok();
7787        let local_var_error = ResponseContent {
7788            status: local_var_status,
7789            content: local_var_content,
7790            entity: local_var_entity,
7791        };
7792        Err(Error::ResponseError(local_var_error))
7793    }
7794}
7795
7796/// Update a list of prefix objects.
7797pub async fn ipam_prefixes_bulk_update(
7798    configuration: &configuration::Configuration,
7799    bulk_writable_prefix_request: Vec<crate::models::BulkWritablePrefixRequest>,
7800    format: Option<&str>,
7801) -> Result<Vec<crate::models::Prefix>, Error<IpamPrefixesBulkUpdateError>> {
7802    let local_var_configuration = configuration;
7803
7804    let local_var_client = &local_var_configuration.client;
7805
7806    let local_var_uri_str = format!("{}/ipam/prefixes/", local_var_configuration.base_path);
7807    let mut local_var_req_builder =
7808        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7809
7810    if let Some(ref local_var_str) = format {
7811        local_var_req_builder =
7812            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7813    }
7814    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7815        local_var_req_builder =
7816            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7817    }
7818    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7819        let local_var_key = local_var_apikey.key.clone();
7820        let local_var_value = match local_var_apikey.prefix {
7821            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7822            None => local_var_key,
7823        };
7824        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7825    };
7826    local_var_req_builder = local_var_req_builder.json(&bulk_writable_prefix_request);
7827
7828    let local_var_req = local_var_req_builder.build()?;
7829    let local_var_resp = local_var_client.execute(local_var_req).await?;
7830
7831    let local_var_status = local_var_resp.status();
7832    let local_var_content = local_var_resp.text().await?;
7833
7834    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7835        serde_json::from_str(&local_var_content).map_err(Error::from)
7836    } else {
7837        let local_var_entity: Option<IpamPrefixesBulkUpdateError> =
7838            serde_json::from_str(&local_var_content).ok();
7839        let local_var_error = ResponseContent {
7840            status: local_var_status,
7841            content: local_var_content,
7842            entity: local_var_entity,
7843        };
7844        Err(Error::ResponseError(local_var_error))
7845    }
7846}
7847
7848/// Create one or more prefix objects.
7849pub async fn ipam_prefixes_create(
7850    configuration: &configuration::Configuration,
7851    writable_prefix_request: crate::models::WritablePrefixRequest,
7852    format: Option<&str>,
7853) -> Result<crate::models::Prefix, Error<IpamPrefixesCreateError>> {
7854    let local_var_configuration = configuration;
7855
7856    let local_var_client = &local_var_configuration.client;
7857
7858    let local_var_uri_str = format!("{}/ipam/prefixes/", local_var_configuration.base_path);
7859    let mut local_var_req_builder =
7860        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7861
7862    if let Some(ref local_var_str) = format {
7863        local_var_req_builder =
7864            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7865    }
7866    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7867        local_var_req_builder =
7868            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7869    }
7870    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7871        let local_var_key = local_var_apikey.key.clone();
7872        let local_var_value = match local_var_apikey.prefix {
7873            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7874            None => local_var_key,
7875        };
7876        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7877    };
7878    local_var_req_builder = local_var_req_builder.json(&writable_prefix_request);
7879
7880    let local_var_req = local_var_req_builder.build()?;
7881    let local_var_resp = local_var_client.execute(local_var_req).await?;
7882
7883    let local_var_status = local_var_resp.status();
7884    let local_var_content = local_var_resp.text().await?;
7885
7886    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7887        serde_json::from_str(&local_var_content).map_err(Error::from)
7888    } else {
7889        let local_var_entity: Option<IpamPrefixesCreateError> =
7890            serde_json::from_str(&local_var_content).ok();
7891        let local_var_error = ResponseContent {
7892            status: local_var_status,
7893            content: local_var_content,
7894            entity: local_var_entity,
7895        };
7896        Err(Error::ResponseError(local_var_error))
7897    }
7898}
7899
7900/// Destroy a prefix object.
7901pub async fn ipam_prefixes_destroy(
7902    configuration: &configuration::Configuration,
7903    id: &str,
7904    format: Option<&str>,
7905) -> Result<(), Error<IpamPrefixesDestroyError>> {
7906    let local_var_configuration = configuration;
7907
7908    let local_var_client = &local_var_configuration.client;
7909
7910    let local_var_uri_str = format!(
7911        "{}/ipam/prefixes/{id}/",
7912        local_var_configuration.base_path,
7913        id = crate::apis::urlencode(id)
7914    );
7915    let mut local_var_req_builder =
7916        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7917
7918    if let Some(ref local_var_str) = format {
7919        local_var_req_builder =
7920            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7921    }
7922    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7923        local_var_req_builder =
7924            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7925    }
7926    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7927        let local_var_key = local_var_apikey.key.clone();
7928        let local_var_value = match local_var_apikey.prefix {
7929            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7930            None => local_var_key,
7931        };
7932        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7933    };
7934
7935    let local_var_req = local_var_req_builder.build()?;
7936    let local_var_resp = local_var_client.execute(local_var_req).await?;
7937
7938    let local_var_status = local_var_resp.status();
7939    let local_var_content = local_var_resp.text().await?;
7940
7941    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7942        Ok(())
7943    } else {
7944        let local_var_entity: Option<IpamPrefixesDestroyError> =
7945            serde_json::from_str(&local_var_content).ok();
7946        let local_var_error = ResponseContent {
7947            status: local_var_status,
7948            content: local_var_content,
7949            entity: local_var_entity,
7950        };
7951        Err(Error::ResponseError(local_var_error))
7952    }
7953}
7954
7955/// Retrieve a list of prefix objects.
7956pub async fn ipam_prefixes_list(
7957    configuration: &configuration::Configuration,
7958    ancestors: Option<Vec<String>>,
7959    cloud_networks: Option<Vec<String>>,
7960    cloud_networks__isnull: Option<bool>,
7961    cloud_networks__n: Option<Vec<String>>,
7962    contacts: Option<Vec<String>>,
7963    contacts__isnull: Option<bool>,
7964    contacts__n: Option<Vec<String>>,
7965    contains: Option<Vec<String>>,
7966    created: Option<Vec<String>>,
7967    created__gt: Option<Vec<String>>,
7968    created__gte: Option<Vec<String>>,
7969    created__isnull: Option<bool>,
7970    created__lt: Option<Vec<String>>,
7971    created__lte: Option<Vec<String>>,
7972    created__n: Option<Vec<String>>,
7973    date_allocated: Option<Vec<String>>,
7974    date_allocated__gt: Option<Vec<String>>,
7975    date_allocated__gte: Option<Vec<String>>,
7976    date_allocated__isnull: Option<bool>,
7977    date_allocated__lt: Option<Vec<String>>,
7978    date_allocated__lte: Option<Vec<String>>,
7979    date_allocated__n: Option<Vec<String>>,
7980    dynamic_groups: Option<Vec<String>>,
7981    dynamic_groups__n: Option<Vec<String>>,
7982    format: Option<&str>,
7983    has_rir: Option<bool>,
7984    id: Option<Vec<uuid::Uuid>>,
7985    id__n: Option<Vec<uuid::Uuid>>,
7986    ip_version: Option<i32>,
7987    last_updated: Option<Vec<String>>,
7988    last_updated__gt: Option<Vec<String>>,
7989    last_updated__gte: Option<Vec<String>>,
7990    last_updated__isnull: Option<bool>,
7991    last_updated__lt: Option<Vec<String>>,
7992    last_updated__lte: Option<Vec<String>>,
7993    last_updated__n: Option<Vec<String>>,
7994    limit: Option<i32>,
7995    location: Option<Vec<String>>,
7996    location__n: Option<Vec<String>>,
7997    locations: Option<Vec<String>>,
7998    locations__n: Option<Vec<String>>,
7999    max_depth: Option<f32>,
8000    namespace: Option<Vec<String>>,
8001    namespace__n: Option<Vec<String>>,
8002    offset: Option<i32>,
8003    parent: Option<Vec<String>>,
8004    parent__isnull: Option<bool>,
8005    parent__n: Option<Vec<String>>,
8006    prefix: Option<Vec<String>>,
8007    prefix_and_descendants: Option<Vec<String>>,
8008    prefix_exact: Option<Vec<String>>,
8009    prefix_length: Option<Vec<i32>>,
8010    prefix_length__gt: Option<Vec<i32>>,
8011    prefix_length__gte: Option<Vec<i32>>,
8012    prefix_length__lt: Option<Vec<i32>>,
8013    prefix_length__lte: Option<Vec<i32>>,
8014    prefix_length__n: Option<Vec<i32>>,
8015    present_in_vrf: Option<&str>,
8016    present_in_vrf_id: Option<&str>,
8017    q: Option<&str>,
8018    rir: Option<Vec<String>>,
8019    rir__isnull: Option<bool>,
8020    rir__n: Option<Vec<String>>,
8021    role: Option<Vec<String>>,
8022    role__isnull: Option<bool>,
8023    role__n: Option<Vec<String>>,
8024    sort: Option<&str>,
8025    status: Option<Vec<String>>,
8026    status__n: Option<Vec<String>>,
8027    tags: Option<Vec<String>>,
8028    tags__isnull: Option<bool>,
8029    tags__n: Option<Vec<String>>,
8030    teams: Option<Vec<String>>,
8031    teams__isnull: Option<bool>,
8032    teams__n: Option<Vec<String>>,
8033    tenant: Option<Vec<String>>,
8034    tenant__isnull: Option<bool>,
8035    tenant__n: Option<Vec<String>>,
8036    tenant_group: Option<Vec<String>>,
8037    tenant_group__isnull: Option<bool>,
8038    tenant_group__n: Option<Vec<String>>,
8039    tenant_id: Option<Vec<uuid::Uuid>>,
8040    tenant_id__isnull: Option<bool>,
8041    tenant_id__n: Option<Vec<uuid::Uuid>>,
8042    r#type: Option<Vec<String>>,
8043    type__ic: Option<Vec<String>>,
8044    type__ie: Option<Vec<String>>,
8045    type__iew: Option<Vec<String>>,
8046    type__ire: Option<Vec<String>>,
8047    type__isw: Option<Vec<String>>,
8048    type__n: Option<Vec<String>>,
8049    type__nic: Option<Vec<String>>,
8050    type__nie: Option<Vec<String>>,
8051    type__niew: Option<Vec<String>>,
8052    type__nire: Option<Vec<String>>,
8053    type__nisw: Option<Vec<String>>,
8054    type__nre: Option<Vec<String>>,
8055    type__re: Option<Vec<String>>,
8056    vlan_id: Option<Vec<uuid::Uuid>>,
8057    vlan_id__isnull: Option<bool>,
8058    vlan_id__n: Option<Vec<uuid::Uuid>>,
8059    vlan_vid: Option<Vec<i32>>,
8060    vlan_vid__gt: Option<Vec<i32>>,
8061    vlan_vid__gte: Option<Vec<i32>>,
8062    vlan_vid__lt: Option<Vec<i32>>,
8063    vlan_vid__lte: Option<Vec<i32>>,
8064    vlan_vid__n: Option<Vec<i32>>,
8065    vpn_tunnel_endpoints: Option<Vec<String>>,
8066    vpn_tunnel_endpoints__isnull: Option<bool>,
8067    vpn_tunnel_endpoints__n: Option<Vec<String>>,
8068    vpn_tunnel_endpoints_name_contains: Option<&str>,
8069    vrfs: Option<Vec<String>>,
8070    vrfs__isnull: Option<bool>,
8071    vrfs__n: Option<Vec<String>>,
8072    within: Option<Vec<String>>,
8073    within_include: Option<Vec<String>>,
8074    depth: Option<i32>,
8075    exclude_m2m: Option<bool>,
8076) -> Result<crate::models::PaginatedPrefixList, Error<IpamPrefixesListError>> {
8077    let local_var_configuration = configuration;
8078
8079    let local_var_client = &local_var_configuration.client;
8080
8081    let local_var_uri_str = format!("{}/ipam/prefixes/", local_var_configuration.base_path);
8082    let mut local_var_req_builder =
8083        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8084
8085    if let Some(ref local_var_str) = ancestors {
8086        local_var_req_builder = match "multi" {
8087            "multi" => local_var_req_builder.query(
8088                &local_var_str
8089                    .into_iter()
8090                    .map(|p| ("ancestors".to_owned(), p.to_string()))
8091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8092            ),
8093            _ => local_var_req_builder.query(&[(
8094                "ancestors",
8095                &local_var_str
8096                    .into_iter()
8097                    .map(|p| p.to_string())
8098                    .collect::<Vec<String>>()
8099                    .join(",")
8100                    .to_string(),
8101            )]),
8102        };
8103    }
8104    if let Some(ref local_var_str) = cloud_networks {
8105        local_var_req_builder = match "multi" {
8106            "multi" => local_var_req_builder.query(
8107                &local_var_str
8108                    .into_iter()
8109                    .map(|p| ("cloud_networks".to_owned(), p.to_string()))
8110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8111            ),
8112            _ => local_var_req_builder.query(&[(
8113                "cloud_networks",
8114                &local_var_str
8115                    .into_iter()
8116                    .map(|p| p.to_string())
8117                    .collect::<Vec<String>>()
8118                    .join(",")
8119                    .to_string(),
8120            )]),
8121        };
8122    }
8123    if let Some(ref local_var_str) = cloud_networks__isnull {
8124        local_var_req_builder =
8125            local_var_req_builder.query(&[("cloud_networks__isnull", &local_var_str.to_string())]);
8126    }
8127    if let Some(ref local_var_str) = cloud_networks__n {
8128        local_var_req_builder = match "multi" {
8129            "multi" => local_var_req_builder.query(
8130                &local_var_str
8131                    .into_iter()
8132                    .map(|p| ("cloud_networks__n".to_owned(), p.to_string()))
8133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8134            ),
8135            _ => local_var_req_builder.query(&[(
8136                "cloud_networks__n",
8137                &local_var_str
8138                    .into_iter()
8139                    .map(|p| p.to_string())
8140                    .collect::<Vec<String>>()
8141                    .join(",")
8142                    .to_string(),
8143            )]),
8144        };
8145    }
8146    if let Some(ref local_var_str) = contacts {
8147        local_var_req_builder = match "multi" {
8148            "multi" => local_var_req_builder.query(
8149                &local_var_str
8150                    .into_iter()
8151                    .map(|p| ("contacts".to_owned(), p.to_string()))
8152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8153            ),
8154            _ => local_var_req_builder.query(&[(
8155                "contacts",
8156                &local_var_str
8157                    .into_iter()
8158                    .map(|p| p.to_string())
8159                    .collect::<Vec<String>>()
8160                    .join(",")
8161                    .to_string(),
8162            )]),
8163        };
8164    }
8165    if let Some(ref local_var_str) = contacts__isnull {
8166        local_var_req_builder =
8167            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
8168    }
8169    if let Some(ref local_var_str) = contacts__n {
8170        local_var_req_builder = match "multi" {
8171            "multi" => local_var_req_builder.query(
8172                &local_var_str
8173                    .into_iter()
8174                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
8175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8176            ),
8177            _ => local_var_req_builder.query(&[(
8178                "contacts__n",
8179                &local_var_str
8180                    .into_iter()
8181                    .map(|p| p.to_string())
8182                    .collect::<Vec<String>>()
8183                    .join(",")
8184                    .to_string(),
8185            )]),
8186        };
8187    }
8188    if let Some(ref local_var_str) = contains {
8189        local_var_req_builder = match "multi" {
8190            "multi" => local_var_req_builder.query(
8191                &local_var_str
8192                    .into_iter()
8193                    .map(|p| ("contains".to_owned(), p.to_string()))
8194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8195            ),
8196            _ => local_var_req_builder.query(&[(
8197                "contains",
8198                &local_var_str
8199                    .into_iter()
8200                    .map(|p| p.to_string())
8201                    .collect::<Vec<String>>()
8202                    .join(",")
8203                    .to_string(),
8204            )]),
8205        };
8206    }
8207    if let Some(ref local_var_str) = created {
8208        local_var_req_builder = match "multi" {
8209            "multi" => local_var_req_builder.query(
8210                &local_var_str
8211                    .into_iter()
8212                    .map(|p| ("created".to_owned(), p.to_string()))
8213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8214            ),
8215            _ => local_var_req_builder.query(&[(
8216                "created",
8217                &local_var_str
8218                    .into_iter()
8219                    .map(|p| p.to_string())
8220                    .collect::<Vec<String>>()
8221                    .join(",")
8222                    .to_string(),
8223            )]),
8224        };
8225    }
8226    if let Some(ref local_var_str) = created__gt {
8227        local_var_req_builder = match "multi" {
8228            "multi" => local_var_req_builder.query(
8229                &local_var_str
8230                    .into_iter()
8231                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8233            ),
8234            _ => local_var_req_builder.query(&[(
8235                "created__gt",
8236                &local_var_str
8237                    .into_iter()
8238                    .map(|p| p.to_string())
8239                    .collect::<Vec<String>>()
8240                    .join(",")
8241                    .to_string(),
8242            )]),
8243        };
8244    }
8245    if let Some(ref local_var_str) = created__gte {
8246        local_var_req_builder = match "multi" {
8247            "multi" => local_var_req_builder.query(
8248                &local_var_str
8249                    .into_iter()
8250                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8252            ),
8253            _ => local_var_req_builder.query(&[(
8254                "created__gte",
8255                &local_var_str
8256                    .into_iter()
8257                    .map(|p| p.to_string())
8258                    .collect::<Vec<String>>()
8259                    .join(",")
8260                    .to_string(),
8261            )]),
8262        };
8263    }
8264    if let Some(ref local_var_str) = created__isnull {
8265        local_var_req_builder =
8266            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
8267    }
8268    if let Some(ref local_var_str) = created__lt {
8269        local_var_req_builder = match "multi" {
8270            "multi" => local_var_req_builder.query(
8271                &local_var_str
8272                    .into_iter()
8273                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8274                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8275            ),
8276            _ => local_var_req_builder.query(&[(
8277                "created__lt",
8278                &local_var_str
8279                    .into_iter()
8280                    .map(|p| p.to_string())
8281                    .collect::<Vec<String>>()
8282                    .join(",")
8283                    .to_string(),
8284            )]),
8285        };
8286    }
8287    if let Some(ref local_var_str) = created__lte {
8288        local_var_req_builder = match "multi" {
8289            "multi" => local_var_req_builder.query(
8290                &local_var_str
8291                    .into_iter()
8292                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8294            ),
8295            _ => local_var_req_builder.query(&[(
8296                "created__lte",
8297                &local_var_str
8298                    .into_iter()
8299                    .map(|p| p.to_string())
8300                    .collect::<Vec<String>>()
8301                    .join(",")
8302                    .to_string(),
8303            )]),
8304        };
8305    }
8306    if let Some(ref local_var_str) = created__n {
8307        local_var_req_builder = match "multi" {
8308            "multi" => local_var_req_builder.query(
8309                &local_var_str
8310                    .into_iter()
8311                    .map(|p| ("created__n".to_owned(), p.to_string()))
8312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8313            ),
8314            _ => local_var_req_builder.query(&[(
8315                "created__n",
8316                &local_var_str
8317                    .into_iter()
8318                    .map(|p| p.to_string())
8319                    .collect::<Vec<String>>()
8320                    .join(",")
8321                    .to_string(),
8322            )]),
8323        };
8324    }
8325    if let Some(ref local_var_str) = date_allocated {
8326        local_var_req_builder = match "multi" {
8327            "multi" => local_var_req_builder.query(
8328                &local_var_str
8329                    .into_iter()
8330                    .map(|p| ("date_allocated".to_owned(), p.to_string()))
8331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8332            ),
8333            _ => local_var_req_builder.query(&[(
8334                "date_allocated",
8335                &local_var_str
8336                    .into_iter()
8337                    .map(|p| p.to_string())
8338                    .collect::<Vec<String>>()
8339                    .join(",")
8340                    .to_string(),
8341            )]),
8342        };
8343    }
8344    if let Some(ref local_var_str) = date_allocated__gt {
8345        local_var_req_builder = match "multi" {
8346            "multi" => local_var_req_builder.query(
8347                &local_var_str
8348                    .into_iter()
8349                    .map(|p| ("date_allocated__gt".to_owned(), p.to_string()))
8350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8351            ),
8352            _ => local_var_req_builder.query(&[(
8353                "date_allocated__gt",
8354                &local_var_str
8355                    .into_iter()
8356                    .map(|p| p.to_string())
8357                    .collect::<Vec<String>>()
8358                    .join(",")
8359                    .to_string(),
8360            )]),
8361        };
8362    }
8363    if let Some(ref local_var_str) = date_allocated__gte {
8364        local_var_req_builder = match "multi" {
8365            "multi" => local_var_req_builder.query(
8366                &local_var_str
8367                    .into_iter()
8368                    .map(|p| ("date_allocated__gte".to_owned(), p.to_string()))
8369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8370            ),
8371            _ => local_var_req_builder.query(&[(
8372                "date_allocated__gte",
8373                &local_var_str
8374                    .into_iter()
8375                    .map(|p| p.to_string())
8376                    .collect::<Vec<String>>()
8377                    .join(",")
8378                    .to_string(),
8379            )]),
8380        };
8381    }
8382    if let Some(ref local_var_str) = date_allocated__isnull {
8383        local_var_req_builder =
8384            local_var_req_builder.query(&[("date_allocated__isnull", &local_var_str.to_string())]);
8385    }
8386    if let Some(ref local_var_str) = date_allocated__lt {
8387        local_var_req_builder = match "multi" {
8388            "multi" => local_var_req_builder.query(
8389                &local_var_str
8390                    .into_iter()
8391                    .map(|p| ("date_allocated__lt".to_owned(), p.to_string()))
8392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8393            ),
8394            _ => local_var_req_builder.query(&[(
8395                "date_allocated__lt",
8396                &local_var_str
8397                    .into_iter()
8398                    .map(|p| p.to_string())
8399                    .collect::<Vec<String>>()
8400                    .join(",")
8401                    .to_string(),
8402            )]),
8403        };
8404    }
8405    if let Some(ref local_var_str) = date_allocated__lte {
8406        local_var_req_builder = match "multi" {
8407            "multi" => local_var_req_builder.query(
8408                &local_var_str
8409                    .into_iter()
8410                    .map(|p| ("date_allocated__lte".to_owned(), p.to_string()))
8411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8412            ),
8413            _ => local_var_req_builder.query(&[(
8414                "date_allocated__lte",
8415                &local_var_str
8416                    .into_iter()
8417                    .map(|p| p.to_string())
8418                    .collect::<Vec<String>>()
8419                    .join(",")
8420                    .to_string(),
8421            )]),
8422        };
8423    }
8424    if let Some(ref local_var_str) = date_allocated__n {
8425        local_var_req_builder = match "multi" {
8426            "multi" => local_var_req_builder.query(
8427                &local_var_str
8428                    .into_iter()
8429                    .map(|p| ("date_allocated__n".to_owned(), p.to_string()))
8430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8431            ),
8432            _ => local_var_req_builder.query(&[(
8433                "date_allocated__n",
8434                &local_var_str
8435                    .into_iter()
8436                    .map(|p| p.to_string())
8437                    .collect::<Vec<String>>()
8438                    .join(",")
8439                    .to_string(),
8440            )]),
8441        };
8442    }
8443    if let Some(ref local_var_str) = dynamic_groups {
8444        local_var_req_builder = match "multi" {
8445            "multi" => local_var_req_builder.query(
8446                &local_var_str
8447                    .into_iter()
8448                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
8449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8450            ),
8451            _ => local_var_req_builder.query(&[(
8452                "dynamic_groups",
8453                &local_var_str
8454                    .into_iter()
8455                    .map(|p| p.to_string())
8456                    .collect::<Vec<String>>()
8457                    .join(",")
8458                    .to_string(),
8459            )]),
8460        };
8461    }
8462    if let Some(ref local_var_str) = dynamic_groups__n {
8463        local_var_req_builder = match "multi" {
8464            "multi" => local_var_req_builder.query(
8465                &local_var_str
8466                    .into_iter()
8467                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
8468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8469            ),
8470            _ => local_var_req_builder.query(&[(
8471                "dynamic_groups__n",
8472                &local_var_str
8473                    .into_iter()
8474                    .map(|p| p.to_string())
8475                    .collect::<Vec<String>>()
8476                    .join(",")
8477                    .to_string(),
8478            )]),
8479        };
8480    }
8481    if let Some(ref local_var_str) = format {
8482        local_var_req_builder =
8483            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8484    }
8485    if let Some(ref local_var_str) = has_rir {
8486        local_var_req_builder =
8487            local_var_req_builder.query(&[("has_rir", &local_var_str.to_string())]);
8488    }
8489    if let Some(ref local_var_str) = id {
8490        local_var_req_builder = match "multi" {
8491            "multi" => local_var_req_builder.query(
8492                &local_var_str
8493                    .into_iter()
8494                    .map(|p| ("id".to_owned(), p.to_string()))
8495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8496            ),
8497            _ => local_var_req_builder.query(&[(
8498                "id",
8499                &local_var_str
8500                    .into_iter()
8501                    .map(|p| p.to_string())
8502                    .collect::<Vec<String>>()
8503                    .join(",")
8504                    .to_string(),
8505            )]),
8506        };
8507    }
8508    if let Some(ref local_var_str) = id__n {
8509        local_var_req_builder = match "multi" {
8510            "multi" => local_var_req_builder.query(
8511                &local_var_str
8512                    .into_iter()
8513                    .map(|p| ("id__n".to_owned(), p.to_string()))
8514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8515            ),
8516            _ => local_var_req_builder.query(&[(
8517                "id__n",
8518                &local_var_str
8519                    .into_iter()
8520                    .map(|p| p.to_string())
8521                    .collect::<Vec<String>>()
8522                    .join(",")
8523                    .to_string(),
8524            )]),
8525        };
8526    }
8527    if let Some(ref local_var_str) = ip_version {
8528        local_var_req_builder =
8529            local_var_req_builder.query(&[("ip_version", &local_var_str.to_string())]);
8530    }
8531    if let Some(ref local_var_str) = last_updated {
8532        local_var_req_builder = match "multi" {
8533            "multi" => local_var_req_builder.query(
8534                &local_var_str
8535                    .into_iter()
8536                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8538            ),
8539            _ => local_var_req_builder.query(&[(
8540                "last_updated",
8541                &local_var_str
8542                    .into_iter()
8543                    .map(|p| p.to_string())
8544                    .collect::<Vec<String>>()
8545                    .join(",")
8546                    .to_string(),
8547            )]),
8548        };
8549    }
8550    if let Some(ref local_var_str) = last_updated__gt {
8551        local_var_req_builder = match "multi" {
8552            "multi" => local_var_req_builder.query(
8553                &local_var_str
8554                    .into_iter()
8555                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8557            ),
8558            _ => local_var_req_builder.query(&[(
8559                "last_updated__gt",
8560                &local_var_str
8561                    .into_iter()
8562                    .map(|p| p.to_string())
8563                    .collect::<Vec<String>>()
8564                    .join(",")
8565                    .to_string(),
8566            )]),
8567        };
8568    }
8569    if let Some(ref local_var_str) = last_updated__gte {
8570        local_var_req_builder = match "multi" {
8571            "multi" => local_var_req_builder.query(
8572                &local_var_str
8573                    .into_iter()
8574                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8576            ),
8577            _ => local_var_req_builder.query(&[(
8578                "last_updated__gte",
8579                &local_var_str
8580                    .into_iter()
8581                    .map(|p| p.to_string())
8582                    .collect::<Vec<String>>()
8583                    .join(",")
8584                    .to_string(),
8585            )]),
8586        };
8587    }
8588    if let Some(ref local_var_str) = last_updated__isnull {
8589        local_var_req_builder =
8590            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
8591    }
8592    if let Some(ref local_var_str) = last_updated__lt {
8593        local_var_req_builder = match "multi" {
8594            "multi" => local_var_req_builder.query(
8595                &local_var_str
8596                    .into_iter()
8597                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8599            ),
8600            _ => local_var_req_builder.query(&[(
8601                "last_updated__lt",
8602                &local_var_str
8603                    .into_iter()
8604                    .map(|p| p.to_string())
8605                    .collect::<Vec<String>>()
8606                    .join(",")
8607                    .to_string(),
8608            )]),
8609        };
8610    }
8611    if let Some(ref local_var_str) = last_updated__lte {
8612        local_var_req_builder = match "multi" {
8613            "multi" => local_var_req_builder.query(
8614                &local_var_str
8615                    .into_iter()
8616                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8618            ),
8619            _ => local_var_req_builder.query(&[(
8620                "last_updated__lte",
8621                &local_var_str
8622                    .into_iter()
8623                    .map(|p| p.to_string())
8624                    .collect::<Vec<String>>()
8625                    .join(",")
8626                    .to_string(),
8627            )]),
8628        };
8629    }
8630    if let Some(ref local_var_str) = last_updated__n {
8631        local_var_req_builder = match "multi" {
8632            "multi" => local_var_req_builder.query(
8633                &local_var_str
8634                    .into_iter()
8635                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8637            ),
8638            _ => local_var_req_builder.query(&[(
8639                "last_updated__n",
8640                &local_var_str
8641                    .into_iter()
8642                    .map(|p| p.to_string())
8643                    .collect::<Vec<String>>()
8644                    .join(",")
8645                    .to_string(),
8646            )]),
8647        };
8648    }
8649    if let Some(ref local_var_str) = limit {
8650        local_var_req_builder =
8651            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8652    }
8653    if let Some(ref local_var_str) = location {
8654        local_var_req_builder = match "multi" {
8655            "multi" => local_var_req_builder.query(
8656                &local_var_str
8657                    .into_iter()
8658                    .map(|p| ("location".to_owned(), p.to_string()))
8659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8660            ),
8661            _ => local_var_req_builder.query(&[(
8662                "location",
8663                &local_var_str
8664                    .into_iter()
8665                    .map(|p| p.to_string())
8666                    .collect::<Vec<String>>()
8667                    .join(",")
8668                    .to_string(),
8669            )]),
8670        };
8671    }
8672    if let Some(ref local_var_str) = location__n {
8673        local_var_req_builder = match "multi" {
8674            "multi" => local_var_req_builder.query(
8675                &local_var_str
8676                    .into_iter()
8677                    .map(|p| ("location__n".to_owned(), p.to_string()))
8678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8679            ),
8680            _ => local_var_req_builder.query(&[(
8681                "location__n",
8682                &local_var_str
8683                    .into_iter()
8684                    .map(|p| p.to_string())
8685                    .collect::<Vec<String>>()
8686                    .join(",")
8687                    .to_string(),
8688            )]),
8689        };
8690    }
8691    if let Some(ref local_var_str) = locations {
8692        local_var_req_builder = match "multi" {
8693            "multi" => local_var_req_builder.query(
8694                &local_var_str
8695                    .into_iter()
8696                    .map(|p| ("locations".to_owned(), p.to_string()))
8697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8698            ),
8699            _ => local_var_req_builder.query(&[(
8700                "locations",
8701                &local_var_str
8702                    .into_iter()
8703                    .map(|p| p.to_string())
8704                    .collect::<Vec<String>>()
8705                    .join(",")
8706                    .to_string(),
8707            )]),
8708        };
8709    }
8710    if let Some(ref local_var_str) = locations__n {
8711        local_var_req_builder = match "multi" {
8712            "multi" => local_var_req_builder.query(
8713                &local_var_str
8714                    .into_iter()
8715                    .map(|p| ("locations__n".to_owned(), p.to_string()))
8716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8717            ),
8718            _ => local_var_req_builder.query(&[(
8719                "locations__n",
8720                &local_var_str
8721                    .into_iter()
8722                    .map(|p| p.to_string())
8723                    .collect::<Vec<String>>()
8724                    .join(",")
8725                    .to_string(),
8726            )]),
8727        };
8728    }
8729    if let Some(ref local_var_str) = max_depth {
8730        local_var_req_builder =
8731            local_var_req_builder.query(&[("max_depth", &local_var_str.to_string())]);
8732    }
8733    if let Some(ref local_var_str) = namespace {
8734        local_var_req_builder = match "multi" {
8735            "multi" => local_var_req_builder.query(
8736                &local_var_str
8737                    .into_iter()
8738                    .map(|p| ("namespace".to_owned(), p.to_string()))
8739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8740            ),
8741            _ => local_var_req_builder.query(&[(
8742                "namespace",
8743                &local_var_str
8744                    .into_iter()
8745                    .map(|p| p.to_string())
8746                    .collect::<Vec<String>>()
8747                    .join(",")
8748                    .to_string(),
8749            )]),
8750        };
8751    }
8752    if let Some(ref local_var_str) = namespace__n {
8753        local_var_req_builder = match "multi" {
8754            "multi" => local_var_req_builder.query(
8755                &local_var_str
8756                    .into_iter()
8757                    .map(|p| ("namespace__n".to_owned(), p.to_string()))
8758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8759            ),
8760            _ => local_var_req_builder.query(&[(
8761                "namespace__n",
8762                &local_var_str
8763                    .into_iter()
8764                    .map(|p| p.to_string())
8765                    .collect::<Vec<String>>()
8766                    .join(",")
8767                    .to_string(),
8768            )]),
8769        };
8770    }
8771    if let Some(ref local_var_str) = offset {
8772        local_var_req_builder =
8773            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8774    }
8775    if let Some(ref local_var_str) = parent {
8776        local_var_req_builder = match "multi" {
8777            "multi" => local_var_req_builder.query(
8778                &local_var_str
8779                    .into_iter()
8780                    .map(|p| ("parent".to_owned(), p.to_string()))
8781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8782            ),
8783            _ => local_var_req_builder.query(&[(
8784                "parent",
8785                &local_var_str
8786                    .into_iter()
8787                    .map(|p| p.to_string())
8788                    .collect::<Vec<String>>()
8789                    .join(",")
8790                    .to_string(),
8791            )]),
8792        };
8793    }
8794    if let Some(ref local_var_str) = parent__isnull {
8795        local_var_req_builder =
8796            local_var_req_builder.query(&[("parent__isnull", &local_var_str.to_string())]);
8797    }
8798    if let Some(ref local_var_str) = parent__n {
8799        local_var_req_builder = match "multi" {
8800            "multi" => local_var_req_builder.query(
8801                &local_var_str
8802                    .into_iter()
8803                    .map(|p| ("parent__n".to_owned(), p.to_string()))
8804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8805            ),
8806            _ => local_var_req_builder.query(&[(
8807                "parent__n",
8808                &local_var_str
8809                    .into_iter()
8810                    .map(|p| p.to_string())
8811                    .collect::<Vec<String>>()
8812                    .join(",")
8813                    .to_string(),
8814            )]),
8815        };
8816    }
8817    if let Some(ref local_var_str) = prefix {
8818        local_var_req_builder = match "multi" {
8819            "multi" => local_var_req_builder.query(
8820                &local_var_str
8821                    .into_iter()
8822                    .map(|p| ("prefix".to_owned(), p.to_string()))
8823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8824            ),
8825            _ => local_var_req_builder.query(&[(
8826                "prefix",
8827                &local_var_str
8828                    .into_iter()
8829                    .map(|p| p.to_string())
8830                    .collect::<Vec<String>>()
8831                    .join(",")
8832                    .to_string(),
8833            )]),
8834        };
8835    }
8836    if let Some(ref local_var_str) = prefix_and_descendants {
8837        local_var_req_builder = match "multi" {
8838            "multi" => local_var_req_builder.query(
8839                &local_var_str
8840                    .into_iter()
8841                    .map(|p| ("prefix_and_descendants".to_owned(), p.to_string()))
8842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8843            ),
8844            _ => local_var_req_builder.query(&[(
8845                "prefix_and_descendants",
8846                &local_var_str
8847                    .into_iter()
8848                    .map(|p| p.to_string())
8849                    .collect::<Vec<String>>()
8850                    .join(",")
8851                    .to_string(),
8852            )]),
8853        };
8854    }
8855    if let Some(ref local_var_str) = prefix_exact {
8856        local_var_req_builder = match "multi" {
8857            "multi" => local_var_req_builder.query(
8858                &local_var_str
8859                    .into_iter()
8860                    .map(|p| ("prefix_exact".to_owned(), p.to_string()))
8861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8862            ),
8863            _ => local_var_req_builder.query(&[(
8864                "prefix_exact",
8865                &local_var_str
8866                    .into_iter()
8867                    .map(|p| p.to_string())
8868                    .collect::<Vec<String>>()
8869                    .join(",")
8870                    .to_string(),
8871            )]),
8872        };
8873    }
8874    if let Some(ref local_var_str) = prefix_length {
8875        local_var_req_builder = match "multi" {
8876            "multi" => local_var_req_builder.query(
8877                &local_var_str
8878                    .into_iter()
8879                    .map(|p| ("prefix_length".to_owned(), p.to_string()))
8880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8881            ),
8882            _ => local_var_req_builder.query(&[(
8883                "prefix_length",
8884                &local_var_str
8885                    .into_iter()
8886                    .map(|p| p.to_string())
8887                    .collect::<Vec<String>>()
8888                    .join(",")
8889                    .to_string(),
8890            )]),
8891        };
8892    }
8893    if let Some(ref local_var_str) = prefix_length__gt {
8894        local_var_req_builder = match "multi" {
8895            "multi" => local_var_req_builder.query(
8896                &local_var_str
8897                    .into_iter()
8898                    .map(|p| ("prefix_length__gt".to_owned(), p.to_string()))
8899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8900            ),
8901            _ => local_var_req_builder.query(&[(
8902                "prefix_length__gt",
8903                &local_var_str
8904                    .into_iter()
8905                    .map(|p| p.to_string())
8906                    .collect::<Vec<String>>()
8907                    .join(",")
8908                    .to_string(),
8909            )]),
8910        };
8911    }
8912    if let Some(ref local_var_str) = prefix_length__gte {
8913        local_var_req_builder = match "multi" {
8914            "multi" => local_var_req_builder.query(
8915                &local_var_str
8916                    .into_iter()
8917                    .map(|p| ("prefix_length__gte".to_owned(), p.to_string()))
8918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8919            ),
8920            _ => local_var_req_builder.query(&[(
8921                "prefix_length__gte",
8922                &local_var_str
8923                    .into_iter()
8924                    .map(|p| p.to_string())
8925                    .collect::<Vec<String>>()
8926                    .join(",")
8927                    .to_string(),
8928            )]),
8929        };
8930    }
8931    if let Some(ref local_var_str) = prefix_length__lt {
8932        local_var_req_builder = match "multi" {
8933            "multi" => local_var_req_builder.query(
8934                &local_var_str
8935                    .into_iter()
8936                    .map(|p| ("prefix_length__lt".to_owned(), p.to_string()))
8937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8938            ),
8939            _ => local_var_req_builder.query(&[(
8940                "prefix_length__lt",
8941                &local_var_str
8942                    .into_iter()
8943                    .map(|p| p.to_string())
8944                    .collect::<Vec<String>>()
8945                    .join(",")
8946                    .to_string(),
8947            )]),
8948        };
8949    }
8950    if let Some(ref local_var_str) = prefix_length__lte {
8951        local_var_req_builder = match "multi" {
8952            "multi" => local_var_req_builder.query(
8953                &local_var_str
8954                    .into_iter()
8955                    .map(|p| ("prefix_length__lte".to_owned(), p.to_string()))
8956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8957            ),
8958            _ => local_var_req_builder.query(&[(
8959                "prefix_length__lte",
8960                &local_var_str
8961                    .into_iter()
8962                    .map(|p| p.to_string())
8963                    .collect::<Vec<String>>()
8964                    .join(",")
8965                    .to_string(),
8966            )]),
8967        };
8968    }
8969    if let Some(ref local_var_str) = prefix_length__n {
8970        local_var_req_builder = match "multi" {
8971            "multi" => local_var_req_builder.query(
8972                &local_var_str
8973                    .into_iter()
8974                    .map(|p| ("prefix_length__n".to_owned(), p.to_string()))
8975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8976            ),
8977            _ => local_var_req_builder.query(&[(
8978                "prefix_length__n",
8979                &local_var_str
8980                    .into_iter()
8981                    .map(|p| p.to_string())
8982                    .collect::<Vec<String>>()
8983                    .join(",")
8984                    .to_string(),
8985            )]),
8986        };
8987    }
8988    if let Some(ref local_var_str) = present_in_vrf {
8989        local_var_req_builder =
8990            local_var_req_builder.query(&[("present_in_vrf", &local_var_str.to_string())]);
8991    }
8992    if let Some(ref local_var_str) = present_in_vrf_id {
8993        local_var_req_builder =
8994            local_var_req_builder.query(&[("present_in_vrf_id", &local_var_str.to_string())]);
8995    }
8996    if let Some(ref local_var_str) = q {
8997        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8998    }
8999    if let Some(ref local_var_str) = rir {
9000        local_var_req_builder = match "multi" {
9001            "multi" => local_var_req_builder.query(
9002                &local_var_str
9003                    .into_iter()
9004                    .map(|p| ("rir".to_owned(), p.to_string()))
9005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9006            ),
9007            _ => local_var_req_builder.query(&[(
9008                "rir",
9009                &local_var_str
9010                    .into_iter()
9011                    .map(|p| p.to_string())
9012                    .collect::<Vec<String>>()
9013                    .join(",")
9014                    .to_string(),
9015            )]),
9016        };
9017    }
9018    if let Some(ref local_var_str) = rir__isnull {
9019        local_var_req_builder =
9020            local_var_req_builder.query(&[("rir__isnull", &local_var_str.to_string())]);
9021    }
9022    if let Some(ref local_var_str) = rir__n {
9023        local_var_req_builder = match "multi" {
9024            "multi" => local_var_req_builder.query(
9025                &local_var_str
9026                    .into_iter()
9027                    .map(|p| ("rir__n".to_owned(), p.to_string()))
9028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9029            ),
9030            _ => local_var_req_builder.query(&[(
9031                "rir__n",
9032                &local_var_str
9033                    .into_iter()
9034                    .map(|p| p.to_string())
9035                    .collect::<Vec<String>>()
9036                    .join(",")
9037                    .to_string(),
9038            )]),
9039        };
9040    }
9041    if let Some(ref local_var_str) = role {
9042        local_var_req_builder = match "multi" {
9043            "multi" => local_var_req_builder.query(
9044                &local_var_str
9045                    .into_iter()
9046                    .map(|p| ("role".to_owned(), p.to_string()))
9047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9048            ),
9049            _ => local_var_req_builder.query(&[(
9050                "role",
9051                &local_var_str
9052                    .into_iter()
9053                    .map(|p| p.to_string())
9054                    .collect::<Vec<String>>()
9055                    .join(",")
9056                    .to_string(),
9057            )]),
9058        };
9059    }
9060    if let Some(ref local_var_str) = role__isnull {
9061        local_var_req_builder =
9062            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
9063    }
9064    if let Some(ref local_var_str) = role__n {
9065        local_var_req_builder = match "multi" {
9066            "multi" => local_var_req_builder.query(
9067                &local_var_str
9068                    .into_iter()
9069                    .map(|p| ("role__n".to_owned(), p.to_string()))
9070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9071            ),
9072            _ => local_var_req_builder.query(&[(
9073                "role__n",
9074                &local_var_str
9075                    .into_iter()
9076                    .map(|p| p.to_string())
9077                    .collect::<Vec<String>>()
9078                    .join(",")
9079                    .to_string(),
9080            )]),
9081        };
9082    }
9083    if let Some(ref local_var_str) = sort {
9084        local_var_req_builder =
9085            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
9086    }
9087    if let Some(ref local_var_str) = status {
9088        local_var_req_builder = match "multi" {
9089            "multi" => local_var_req_builder.query(
9090                &local_var_str
9091                    .into_iter()
9092                    .map(|p| ("status".to_owned(), p.to_string()))
9093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9094            ),
9095            _ => local_var_req_builder.query(&[(
9096                "status",
9097                &local_var_str
9098                    .into_iter()
9099                    .map(|p| p.to_string())
9100                    .collect::<Vec<String>>()
9101                    .join(",")
9102                    .to_string(),
9103            )]),
9104        };
9105    }
9106    if let Some(ref local_var_str) = status__n {
9107        local_var_req_builder = match "multi" {
9108            "multi" => local_var_req_builder.query(
9109                &local_var_str
9110                    .into_iter()
9111                    .map(|p| ("status__n".to_owned(), p.to_string()))
9112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9113            ),
9114            _ => local_var_req_builder.query(&[(
9115                "status__n",
9116                &local_var_str
9117                    .into_iter()
9118                    .map(|p| p.to_string())
9119                    .collect::<Vec<String>>()
9120                    .join(",")
9121                    .to_string(),
9122            )]),
9123        };
9124    }
9125    if let Some(ref local_var_str) = tags {
9126        local_var_req_builder = match "multi" {
9127            "multi" => local_var_req_builder.query(
9128                &local_var_str
9129                    .into_iter()
9130                    .map(|p| ("tags".to_owned(), p.to_string()))
9131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9132            ),
9133            _ => local_var_req_builder.query(&[(
9134                "tags",
9135                &local_var_str
9136                    .into_iter()
9137                    .map(|p| p.to_string())
9138                    .collect::<Vec<String>>()
9139                    .join(",")
9140                    .to_string(),
9141            )]),
9142        };
9143    }
9144    if let Some(ref local_var_str) = tags__isnull {
9145        local_var_req_builder =
9146            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
9147    }
9148    if let Some(ref local_var_str) = tags__n {
9149        local_var_req_builder = match "multi" {
9150            "multi" => local_var_req_builder.query(
9151                &local_var_str
9152                    .into_iter()
9153                    .map(|p| ("tags__n".to_owned(), p.to_string()))
9154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9155            ),
9156            _ => local_var_req_builder.query(&[(
9157                "tags__n",
9158                &local_var_str
9159                    .into_iter()
9160                    .map(|p| p.to_string())
9161                    .collect::<Vec<String>>()
9162                    .join(",")
9163                    .to_string(),
9164            )]),
9165        };
9166    }
9167    if let Some(ref local_var_str) = teams {
9168        local_var_req_builder = match "multi" {
9169            "multi" => local_var_req_builder.query(
9170                &local_var_str
9171                    .into_iter()
9172                    .map(|p| ("teams".to_owned(), p.to_string()))
9173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9174            ),
9175            _ => local_var_req_builder.query(&[(
9176                "teams",
9177                &local_var_str
9178                    .into_iter()
9179                    .map(|p| p.to_string())
9180                    .collect::<Vec<String>>()
9181                    .join(",")
9182                    .to_string(),
9183            )]),
9184        };
9185    }
9186    if let Some(ref local_var_str) = teams__isnull {
9187        local_var_req_builder =
9188            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
9189    }
9190    if let Some(ref local_var_str) = teams__n {
9191        local_var_req_builder = match "multi" {
9192            "multi" => local_var_req_builder.query(
9193                &local_var_str
9194                    .into_iter()
9195                    .map(|p| ("teams__n".to_owned(), p.to_string()))
9196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9197            ),
9198            _ => local_var_req_builder.query(&[(
9199                "teams__n",
9200                &local_var_str
9201                    .into_iter()
9202                    .map(|p| p.to_string())
9203                    .collect::<Vec<String>>()
9204                    .join(",")
9205                    .to_string(),
9206            )]),
9207        };
9208    }
9209    if let Some(ref local_var_str) = tenant {
9210        local_var_req_builder = match "multi" {
9211            "multi" => local_var_req_builder.query(
9212                &local_var_str
9213                    .into_iter()
9214                    .map(|p| ("tenant".to_owned(), p.to_string()))
9215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9216            ),
9217            _ => local_var_req_builder.query(&[(
9218                "tenant",
9219                &local_var_str
9220                    .into_iter()
9221                    .map(|p| p.to_string())
9222                    .collect::<Vec<String>>()
9223                    .join(",")
9224                    .to_string(),
9225            )]),
9226        };
9227    }
9228    if let Some(ref local_var_str) = tenant__isnull {
9229        local_var_req_builder =
9230            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
9231    }
9232    if let Some(ref local_var_str) = tenant__n {
9233        local_var_req_builder = match "multi" {
9234            "multi" => local_var_req_builder.query(
9235                &local_var_str
9236                    .into_iter()
9237                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
9238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9239            ),
9240            _ => local_var_req_builder.query(&[(
9241                "tenant__n",
9242                &local_var_str
9243                    .into_iter()
9244                    .map(|p| p.to_string())
9245                    .collect::<Vec<String>>()
9246                    .join(",")
9247                    .to_string(),
9248            )]),
9249        };
9250    }
9251    if let Some(ref local_var_str) = tenant_group {
9252        local_var_req_builder = match "multi" {
9253            "multi" => local_var_req_builder.query(
9254                &local_var_str
9255                    .into_iter()
9256                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
9257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9258            ),
9259            _ => local_var_req_builder.query(&[(
9260                "tenant_group",
9261                &local_var_str
9262                    .into_iter()
9263                    .map(|p| p.to_string())
9264                    .collect::<Vec<String>>()
9265                    .join(",")
9266                    .to_string(),
9267            )]),
9268        };
9269    }
9270    if let Some(ref local_var_str) = tenant_group__isnull {
9271        local_var_req_builder =
9272            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
9273    }
9274    if let Some(ref local_var_str) = tenant_group__n {
9275        local_var_req_builder = match "multi" {
9276            "multi" => local_var_req_builder.query(
9277                &local_var_str
9278                    .into_iter()
9279                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
9280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9281            ),
9282            _ => local_var_req_builder.query(&[(
9283                "tenant_group__n",
9284                &local_var_str
9285                    .into_iter()
9286                    .map(|p| p.to_string())
9287                    .collect::<Vec<String>>()
9288                    .join(",")
9289                    .to_string(),
9290            )]),
9291        };
9292    }
9293    if let Some(ref local_var_str) = tenant_id {
9294        local_var_req_builder = match "multi" {
9295            "multi" => local_var_req_builder.query(
9296                &local_var_str
9297                    .into_iter()
9298                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
9299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9300            ),
9301            _ => local_var_req_builder.query(&[(
9302                "tenant_id",
9303                &local_var_str
9304                    .into_iter()
9305                    .map(|p| p.to_string())
9306                    .collect::<Vec<String>>()
9307                    .join(",")
9308                    .to_string(),
9309            )]),
9310        };
9311    }
9312    if let Some(ref local_var_str) = tenant_id__isnull {
9313        local_var_req_builder =
9314            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
9315    }
9316    if let Some(ref local_var_str) = tenant_id__n {
9317        local_var_req_builder = match "multi" {
9318            "multi" => local_var_req_builder.query(
9319                &local_var_str
9320                    .into_iter()
9321                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
9322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9323            ),
9324            _ => local_var_req_builder.query(&[(
9325                "tenant_id__n",
9326                &local_var_str
9327                    .into_iter()
9328                    .map(|p| p.to_string())
9329                    .collect::<Vec<String>>()
9330                    .join(",")
9331                    .to_string(),
9332            )]),
9333        };
9334    }
9335    if let Some(ref local_var_str) = r#type {
9336        local_var_req_builder = match "multi" {
9337            "multi" => local_var_req_builder.query(
9338                &local_var_str
9339                    .into_iter()
9340                    .map(|p| ("type".to_owned(), p.to_string()))
9341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9342            ),
9343            _ => local_var_req_builder.query(&[(
9344                "type",
9345                &local_var_str
9346                    .into_iter()
9347                    .map(|p| p.to_string())
9348                    .collect::<Vec<String>>()
9349                    .join(",")
9350                    .to_string(),
9351            )]),
9352        };
9353    }
9354    if let Some(ref local_var_str) = type__ic {
9355        local_var_req_builder = match "multi" {
9356            "multi" => local_var_req_builder.query(
9357                &local_var_str
9358                    .into_iter()
9359                    .map(|p| ("type__ic".to_owned(), p.to_string()))
9360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9361            ),
9362            _ => local_var_req_builder.query(&[(
9363                "type__ic",
9364                &local_var_str
9365                    .into_iter()
9366                    .map(|p| p.to_string())
9367                    .collect::<Vec<String>>()
9368                    .join(",")
9369                    .to_string(),
9370            )]),
9371        };
9372    }
9373    if let Some(ref local_var_str) = type__ie {
9374        local_var_req_builder = match "multi" {
9375            "multi" => local_var_req_builder.query(
9376                &local_var_str
9377                    .into_iter()
9378                    .map(|p| ("type__ie".to_owned(), p.to_string()))
9379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9380            ),
9381            _ => local_var_req_builder.query(&[(
9382                "type__ie",
9383                &local_var_str
9384                    .into_iter()
9385                    .map(|p| p.to_string())
9386                    .collect::<Vec<String>>()
9387                    .join(",")
9388                    .to_string(),
9389            )]),
9390        };
9391    }
9392    if let Some(ref local_var_str) = type__iew {
9393        local_var_req_builder = match "multi" {
9394            "multi" => local_var_req_builder.query(
9395                &local_var_str
9396                    .into_iter()
9397                    .map(|p| ("type__iew".to_owned(), p.to_string()))
9398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9399            ),
9400            _ => local_var_req_builder.query(&[(
9401                "type__iew",
9402                &local_var_str
9403                    .into_iter()
9404                    .map(|p| p.to_string())
9405                    .collect::<Vec<String>>()
9406                    .join(",")
9407                    .to_string(),
9408            )]),
9409        };
9410    }
9411    if let Some(ref local_var_str) = type__ire {
9412        local_var_req_builder = match "multi" {
9413            "multi" => local_var_req_builder.query(
9414                &local_var_str
9415                    .into_iter()
9416                    .map(|p| ("type__ire".to_owned(), p.to_string()))
9417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9418            ),
9419            _ => local_var_req_builder.query(&[(
9420                "type__ire",
9421                &local_var_str
9422                    .into_iter()
9423                    .map(|p| p.to_string())
9424                    .collect::<Vec<String>>()
9425                    .join(",")
9426                    .to_string(),
9427            )]),
9428        };
9429    }
9430    if let Some(ref local_var_str) = type__isw {
9431        local_var_req_builder = match "multi" {
9432            "multi" => local_var_req_builder.query(
9433                &local_var_str
9434                    .into_iter()
9435                    .map(|p| ("type__isw".to_owned(), p.to_string()))
9436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9437            ),
9438            _ => local_var_req_builder.query(&[(
9439                "type__isw",
9440                &local_var_str
9441                    .into_iter()
9442                    .map(|p| p.to_string())
9443                    .collect::<Vec<String>>()
9444                    .join(",")
9445                    .to_string(),
9446            )]),
9447        };
9448    }
9449    if let Some(ref local_var_str) = type__n {
9450        local_var_req_builder = match "multi" {
9451            "multi" => local_var_req_builder.query(
9452                &local_var_str
9453                    .into_iter()
9454                    .map(|p| ("type__n".to_owned(), p.to_string()))
9455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9456            ),
9457            _ => local_var_req_builder.query(&[(
9458                "type__n",
9459                &local_var_str
9460                    .into_iter()
9461                    .map(|p| p.to_string())
9462                    .collect::<Vec<String>>()
9463                    .join(",")
9464                    .to_string(),
9465            )]),
9466        };
9467    }
9468    if let Some(ref local_var_str) = type__nic {
9469        local_var_req_builder = match "multi" {
9470            "multi" => local_var_req_builder.query(
9471                &local_var_str
9472                    .into_iter()
9473                    .map(|p| ("type__nic".to_owned(), p.to_string()))
9474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9475            ),
9476            _ => local_var_req_builder.query(&[(
9477                "type__nic",
9478                &local_var_str
9479                    .into_iter()
9480                    .map(|p| p.to_string())
9481                    .collect::<Vec<String>>()
9482                    .join(",")
9483                    .to_string(),
9484            )]),
9485        };
9486    }
9487    if let Some(ref local_var_str) = type__nie {
9488        local_var_req_builder = match "multi" {
9489            "multi" => local_var_req_builder.query(
9490                &local_var_str
9491                    .into_iter()
9492                    .map(|p| ("type__nie".to_owned(), p.to_string()))
9493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9494            ),
9495            _ => local_var_req_builder.query(&[(
9496                "type__nie",
9497                &local_var_str
9498                    .into_iter()
9499                    .map(|p| p.to_string())
9500                    .collect::<Vec<String>>()
9501                    .join(",")
9502                    .to_string(),
9503            )]),
9504        };
9505    }
9506    if let Some(ref local_var_str) = type__niew {
9507        local_var_req_builder = match "multi" {
9508            "multi" => local_var_req_builder.query(
9509                &local_var_str
9510                    .into_iter()
9511                    .map(|p| ("type__niew".to_owned(), p.to_string()))
9512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9513            ),
9514            _ => local_var_req_builder.query(&[(
9515                "type__niew",
9516                &local_var_str
9517                    .into_iter()
9518                    .map(|p| p.to_string())
9519                    .collect::<Vec<String>>()
9520                    .join(",")
9521                    .to_string(),
9522            )]),
9523        };
9524    }
9525    if let Some(ref local_var_str) = type__nire {
9526        local_var_req_builder = match "multi" {
9527            "multi" => local_var_req_builder.query(
9528                &local_var_str
9529                    .into_iter()
9530                    .map(|p| ("type__nire".to_owned(), p.to_string()))
9531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9532            ),
9533            _ => local_var_req_builder.query(&[(
9534                "type__nire",
9535                &local_var_str
9536                    .into_iter()
9537                    .map(|p| p.to_string())
9538                    .collect::<Vec<String>>()
9539                    .join(",")
9540                    .to_string(),
9541            )]),
9542        };
9543    }
9544    if let Some(ref local_var_str) = type__nisw {
9545        local_var_req_builder = match "multi" {
9546            "multi" => local_var_req_builder.query(
9547                &local_var_str
9548                    .into_iter()
9549                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
9550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9551            ),
9552            _ => local_var_req_builder.query(&[(
9553                "type__nisw",
9554                &local_var_str
9555                    .into_iter()
9556                    .map(|p| p.to_string())
9557                    .collect::<Vec<String>>()
9558                    .join(",")
9559                    .to_string(),
9560            )]),
9561        };
9562    }
9563    if let Some(ref local_var_str) = type__nre {
9564        local_var_req_builder = match "multi" {
9565            "multi" => local_var_req_builder.query(
9566                &local_var_str
9567                    .into_iter()
9568                    .map(|p| ("type__nre".to_owned(), p.to_string()))
9569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9570            ),
9571            _ => local_var_req_builder.query(&[(
9572                "type__nre",
9573                &local_var_str
9574                    .into_iter()
9575                    .map(|p| p.to_string())
9576                    .collect::<Vec<String>>()
9577                    .join(",")
9578                    .to_string(),
9579            )]),
9580        };
9581    }
9582    if let Some(ref local_var_str) = type__re {
9583        local_var_req_builder = match "multi" {
9584            "multi" => local_var_req_builder.query(
9585                &local_var_str
9586                    .into_iter()
9587                    .map(|p| ("type__re".to_owned(), p.to_string()))
9588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9589            ),
9590            _ => local_var_req_builder.query(&[(
9591                "type__re",
9592                &local_var_str
9593                    .into_iter()
9594                    .map(|p| p.to_string())
9595                    .collect::<Vec<String>>()
9596                    .join(",")
9597                    .to_string(),
9598            )]),
9599        };
9600    }
9601    if let Some(ref local_var_str) = vlan_id {
9602        local_var_req_builder = match "multi" {
9603            "multi" => local_var_req_builder.query(
9604                &local_var_str
9605                    .into_iter()
9606                    .map(|p| ("vlan_id".to_owned(), p.to_string()))
9607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9608            ),
9609            _ => local_var_req_builder.query(&[(
9610                "vlan_id",
9611                &local_var_str
9612                    .into_iter()
9613                    .map(|p| p.to_string())
9614                    .collect::<Vec<String>>()
9615                    .join(",")
9616                    .to_string(),
9617            )]),
9618        };
9619    }
9620    if let Some(ref local_var_str) = vlan_id__isnull {
9621        local_var_req_builder =
9622            local_var_req_builder.query(&[("vlan_id__isnull", &local_var_str.to_string())]);
9623    }
9624    if let Some(ref local_var_str) = vlan_id__n {
9625        local_var_req_builder = match "multi" {
9626            "multi" => local_var_req_builder.query(
9627                &local_var_str
9628                    .into_iter()
9629                    .map(|p| ("vlan_id__n".to_owned(), p.to_string()))
9630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9631            ),
9632            _ => local_var_req_builder.query(&[(
9633                "vlan_id__n",
9634                &local_var_str
9635                    .into_iter()
9636                    .map(|p| p.to_string())
9637                    .collect::<Vec<String>>()
9638                    .join(",")
9639                    .to_string(),
9640            )]),
9641        };
9642    }
9643    if let Some(ref local_var_str) = vlan_vid {
9644        local_var_req_builder = match "multi" {
9645            "multi" => local_var_req_builder.query(
9646                &local_var_str
9647                    .into_iter()
9648                    .map(|p| ("vlan_vid".to_owned(), p.to_string()))
9649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9650            ),
9651            _ => local_var_req_builder.query(&[(
9652                "vlan_vid",
9653                &local_var_str
9654                    .into_iter()
9655                    .map(|p| p.to_string())
9656                    .collect::<Vec<String>>()
9657                    .join(",")
9658                    .to_string(),
9659            )]),
9660        };
9661    }
9662    if let Some(ref local_var_str) = vlan_vid__gt {
9663        local_var_req_builder = match "multi" {
9664            "multi" => local_var_req_builder.query(
9665                &local_var_str
9666                    .into_iter()
9667                    .map(|p| ("vlan_vid__gt".to_owned(), p.to_string()))
9668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9669            ),
9670            _ => local_var_req_builder.query(&[(
9671                "vlan_vid__gt",
9672                &local_var_str
9673                    .into_iter()
9674                    .map(|p| p.to_string())
9675                    .collect::<Vec<String>>()
9676                    .join(",")
9677                    .to_string(),
9678            )]),
9679        };
9680    }
9681    if let Some(ref local_var_str) = vlan_vid__gte {
9682        local_var_req_builder = match "multi" {
9683            "multi" => local_var_req_builder.query(
9684                &local_var_str
9685                    .into_iter()
9686                    .map(|p| ("vlan_vid__gte".to_owned(), p.to_string()))
9687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9688            ),
9689            _ => local_var_req_builder.query(&[(
9690                "vlan_vid__gte",
9691                &local_var_str
9692                    .into_iter()
9693                    .map(|p| p.to_string())
9694                    .collect::<Vec<String>>()
9695                    .join(",")
9696                    .to_string(),
9697            )]),
9698        };
9699    }
9700    if let Some(ref local_var_str) = vlan_vid__lt {
9701        local_var_req_builder = match "multi" {
9702            "multi" => local_var_req_builder.query(
9703                &local_var_str
9704                    .into_iter()
9705                    .map(|p| ("vlan_vid__lt".to_owned(), p.to_string()))
9706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9707            ),
9708            _ => local_var_req_builder.query(&[(
9709                "vlan_vid__lt",
9710                &local_var_str
9711                    .into_iter()
9712                    .map(|p| p.to_string())
9713                    .collect::<Vec<String>>()
9714                    .join(",")
9715                    .to_string(),
9716            )]),
9717        };
9718    }
9719    if let Some(ref local_var_str) = vlan_vid__lte {
9720        local_var_req_builder = match "multi" {
9721            "multi" => local_var_req_builder.query(
9722                &local_var_str
9723                    .into_iter()
9724                    .map(|p| ("vlan_vid__lte".to_owned(), p.to_string()))
9725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9726            ),
9727            _ => local_var_req_builder.query(&[(
9728                "vlan_vid__lte",
9729                &local_var_str
9730                    .into_iter()
9731                    .map(|p| p.to_string())
9732                    .collect::<Vec<String>>()
9733                    .join(",")
9734                    .to_string(),
9735            )]),
9736        };
9737    }
9738    if let Some(ref local_var_str) = vlan_vid__n {
9739        local_var_req_builder = match "multi" {
9740            "multi" => local_var_req_builder.query(
9741                &local_var_str
9742                    .into_iter()
9743                    .map(|p| ("vlan_vid__n".to_owned(), p.to_string()))
9744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9745            ),
9746            _ => local_var_req_builder.query(&[(
9747                "vlan_vid__n",
9748                &local_var_str
9749                    .into_iter()
9750                    .map(|p| p.to_string())
9751                    .collect::<Vec<String>>()
9752                    .join(",")
9753                    .to_string(),
9754            )]),
9755        };
9756    }
9757    if let Some(ref local_var_str) = vpn_tunnel_endpoints {
9758        local_var_req_builder = match "multi" {
9759            "multi" => local_var_req_builder.query(
9760                &local_var_str
9761                    .into_iter()
9762                    .map(|p| ("vpn_tunnel_endpoints".to_owned(), p.to_string()))
9763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9764            ),
9765            _ => local_var_req_builder.query(&[(
9766                "vpn_tunnel_endpoints",
9767                &local_var_str
9768                    .into_iter()
9769                    .map(|p| p.to_string())
9770                    .collect::<Vec<String>>()
9771                    .join(",")
9772                    .to_string(),
9773            )]),
9774        };
9775    }
9776    if let Some(ref local_var_str) = vpn_tunnel_endpoints__isnull {
9777        local_var_req_builder = local_var_req_builder
9778            .query(&[("vpn_tunnel_endpoints__isnull", &local_var_str.to_string())]);
9779    }
9780    if let Some(ref local_var_str) = vpn_tunnel_endpoints__n {
9781        local_var_req_builder = match "multi" {
9782            "multi" => local_var_req_builder.query(
9783                &local_var_str
9784                    .into_iter()
9785                    .map(|p| ("vpn_tunnel_endpoints__n".to_owned(), p.to_string()))
9786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9787            ),
9788            _ => local_var_req_builder.query(&[(
9789                "vpn_tunnel_endpoints__n",
9790                &local_var_str
9791                    .into_iter()
9792                    .map(|p| p.to_string())
9793                    .collect::<Vec<String>>()
9794                    .join(",")
9795                    .to_string(),
9796            )]),
9797        };
9798    }
9799    if let Some(ref local_var_str) = vpn_tunnel_endpoints_name_contains {
9800        local_var_req_builder = local_var_req_builder.query(&[(
9801            "vpn_tunnel_endpoints_name_contains",
9802            &local_var_str.to_string(),
9803        )]);
9804    }
9805    if let Some(ref local_var_str) = vrfs {
9806        local_var_req_builder = match "multi" {
9807            "multi" => local_var_req_builder.query(
9808                &local_var_str
9809                    .into_iter()
9810                    .map(|p| ("vrfs".to_owned(), p.to_string()))
9811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9812            ),
9813            _ => local_var_req_builder.query(&[(
9814                "vrfs",
9815                &local_var_str
9816                    .into_iter()
9817                    .map(|p| p.to_string())
9818                    .collect::<Vec<String>>()
9819                    .join(",")
9820                    .to_string(),
9821            )]),
9822        };
9823    }
9824    if let Some(ref local_var_str) = vrfs__isnull {
9825        local_var_req_builder =
9826            local_var_req_builder.query(&[("vrfs__isnull", &local_var_str.to_string())]);
9827    }
9828    if let Some(ref local_var_str) = vrfs__n {
9829        local_var_req_builder = match "multi" {
9830            "multi" => local_var_req_builder.query(
9831                &local_var_str
9832                    .into_iter()
9833                    .map(|p| ("vrfs__n".to_owned(), p.to_string()))
9834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9835            ),
9836            _ => local_var_req_builder.query(&[(
9837                "vrfs__n",
9838                &local_var_str
9839                    .into_iter()
9840                    .map(|p| p.to_string())
9841                    .collect::<Vec<String>>()
9842                    .join(",")
9843                    .to_string(),
9844            )]),
9845        };
9846    }
9847    if let Some(ref local_var_str) = within {
9848        local_var_req_builder = match "multi" {
9849            "multi" => local_var_req_builder.query(
9850                &local_var_str
9851                    .into_iter()
9852                    .map(|p| ("within".to_owned(), p.to_string()))
9853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9854            ),
9855            _ => local_var_req_builder.query(&[(
9856                "within",
9857                &local_var_str
9858                    .into_iter()
9859                    .map(|p| p.to_string())
9860                    .collect::<Vec<String>>()
9861                    .join(",")
9862                    .to_string(),
9863            )]),
9864        };
9865    }
9866    if let Some(ref local_var_str) = within_include {
9867        local_var_req_builder = match "multi" {
9868            "multi" => local_var_req_builder.query(
9869                &local_var_str
9870                    .into_iter()
9871                    .map(|p| ("within_include".to_owned(), p.to_string()))
9872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9873            ),
9874            _ => local_var_req_builder.query(&[(
9875                "within_include",
9876                &local_var_str
9877                    .into_iter()
9878                    .map(|p| p.to_string())
9879                    .collect::<Vec<String>>()
9880                    .join(",")
9881                    .to_string(),
9882            )]),
9883        };
9884    }
9885    if let Some(ref local_var_str) = depth {
9886        local_var_req_builder =
9887            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9888    }
9889    if let Some(ref local_var_str) = exclude_m2m {
9890        local_var_req_builder =
9891            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9892    }
9893    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9894        local_var_req_builder =
9895            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9896    }
9897    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9898        let local_var_key = local_var_apikey.key.clone();
9899        let local_var_value = match local_var_apikey.prefix {
9900            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9901            None => local_var_key,
9902        };
9903        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9904    };
9905
9906    let local_var_req = local_var_req_builder.build()?;
9907    let local_var_resp = local_var_client.execute(local_var_req).await?;
9908
9909    let local_var_status = local_var_resp.status();
9910    let local_var_content = local_var_resp.text().await?;
9911
9912    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9913        serde_json::from_str(&local_var_content).map_err(Error::from)
9914    } else {
9915        let local_var_entity: Option<IpamPrefixesListError> =
9916            serde_json::from_str(&local_var_content).ok();
9917        let local_var_error = ResponseContent {
9918            status: local_var_status,
9919            content: local_var_content,
9920            entity: local_var_entity,
9921        };
9922        Err(Error::ResponseError(local_var_error))
9923    }
9924}
9925
9926/// API methods for returning or creating notes on an object.
9927pub async fn ipam_prefixes_notes_create(
9928    configuration: &configuration::Configuration,
9929    id: &str,
9930    note_input_request: crate::models::NoteInputRequest,
9931    format: Option<&str>,
9932) -> Result<crate::models::Note, Error<IpamPrefixesNotesCreateError>> {
9933    let local_var_configuration = configuration;
9934
9935    let local_var_client = &local_var_configuration.client;
9936
9937    let local_var_uri_str = format!(
9938        "{}/ipam/prefixes/{id}/notes/",
9939        local_var_configuration.base_path,
9940        id = crate::apis::urlencode(id)
9941    );
9942    let mut local_var_req_builder =
9943        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9944
9945    if let Some(ref local_var_str) = format {
9946        local_var_req_builder =
9947            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9948    }
9949    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9950        local_var_req_builder =
9951            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9952    }
9953    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9954        let local_var_key = local_var_apikey.key.clone();
9955        let local_var_value = match local_var_apikey.prefix {
9956            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9957            None => local_var_key,
9958        };
9959        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9960    };
9961    local_var_req_builder = local_var_req_builder.json(&note_input_request);
9962
9963    let local_var_req = local_var_req_builder.build()?;
9964    let local_var_resp = local_var_client.execute(local_var_req).await?;
9965
9966    let local_var_status = local_var_resp.status();
9967    let local_var_content = local_var_resp.text().await?;
9968
9969    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9970        serde_json::from_str(&local_var_content).map_err(Error::from)
9971    } else {
9972        let local_var_entity: Option<IpamPrefixesNotesCreateError> =
9973            serde_json::from_str(&local_var_content).ok();
9974        let local_var_error = ResponseContent {
9975            status: local_var_status,
9976            content: local_var_content,
9977            entity: local_var_entity,
9978        };
9979        Err(Error::ResponseError(local_var_error))
9980    }
9981}
9982
9983/// API methods for returning or creating notes on an object.
9984pub async fn ipam_prefixes_notes_list(
9985    configuration: &configuration::Configuration,
9986    id: &str,
9987    format: Option<&str>,
9988    limit: Option<i32>,
9989    offset: Option<i32>,
9990    depth: Option<i32>,
9991    exclude_m2m: Option<bool>,
9992) -> Result<crate::models::PaginatedNoteList, Error<IpamPrefixesNotesListError>> {
9993    let local_var_configuration = configuration;
9994
9995    let local_var_client = &local_var_configuration.client;
9996
9997    let local_var_uri_str = format!(
9998        "{}/ipam/prefixes/{id}/notes/",
9999        local_var_configuration.base_path,
10000        id = crate::apis::urlencode(id)
10001    );
10002    let mut local_var_req_builder =
10003        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10004
10005    if let Some(ref local_var_str) = format {
10006        local_var_req_builder =
10007            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10008    }
10009    if let Some(ref local_var_str) = limit {
10010        local_var_req_builder =
10011            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10012    }
10013    if let Some(ref local_var_str) = offset {
10014        local_var_req_builder =
10015            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10016    }
10017    if let Some(ref local_var_str) = depth {
10018        local_var_req_builder =
10019            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10020    }
10021    if let Some(ref local_var_str) = exclude_m2m {
10022        local_var_req_builder =
10023            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10024    }
10025    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10026        local_var_req_builder =
10027            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10028    }
10029    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10030        let local_var_key = local_var_apikey.key.clone();
10031        let local_var_value = match local_var_apikey.prefix {
10032            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10033            None => local_var_key,
10034        };
10035        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10036    };
10037
10038    let local_var_req = local_var_req_builder.build()?;
10039    let local_var_resp = local_var_client.execute(local_var_req).await?;
10040
10041    let local_var_status = local_var_resp.status();
10042    let local_var_content = local_var_resp.text().await?;
10043
10044    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10045        serde_json::from_str(&local_var_content).map_err(Error::from)
10046    } else {
10047        let local_var_entity: Option<IpamPrefixesNotesListError> =
10048            serde_json::from_str(&local_var_content).ok();
10049        let local_var_error = ResponseContent {
10050            status: local_var_status,
10051            content: local_var_content,
10052            entity: local_var_entity,
10053        };
10054        Err(Error::ResponseError(local_var_error))
10055    }
10056}
10057
10058/// Partial update a prefix object.
10059pub async fn ipam_prefixes_partial_update(
10060    configuration: &configuration::Configuration,
10061    id: &str,
10062    format: Option<&str>,
10063    patched_writable_prefix_request: Option<crate::models::PatchedWritablePrefixRequest>,
10064) -> Result<crate::models::Prefix, Error<IpamPrefixesPartialUpdateError>> {
10065    let local_var_configuration = configuration;
10066
10067    let local_var_client = &local_var_configuration.client;
10068
10069    let local_var_uri_str = format!(
10070        "{}/ipam/prefixes/{id}/",
10071        local_var_configuration.base_path,
10072        id = crate::apis::urlencode(id)
10073    );
10074    let mut local_var_req_builder =
10075        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10076
10077    if let Some(ref local_var_str) = format {
10078        local_var_req_builder =
10079            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10080    }
10081    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10082        local_var_req_builder =
10083            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10084    }
10085    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10086        let local_var_key = local_var_apikey.key.clone();
10087        let local_var_value = match local_var_apikey.prefix {
10088            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10089            None => local_var_key,
10090        };
10091        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10092    };
10093    local_var_req_builder = local_var_req_builder.json(&patched_writable_prefix_request);
10094
10095    let local_var_req = local_var_req_builder.build()?;
10096    let local_var_resp = local_var_client.execute(local_var_req).await?;
10097
10098    let local_var_status = local_var_resp.status();
10099    let local_var_content = local_var_resp.text().await?;
10100
10101    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10102        serde_json::from_str(&local_var_content).map_err(Error::from)
10103    } else {
10104        let local_var_entity: Option<IpamPrefixesPartialUpdateError> =
10105            serde_json::from_str(&local_var_content).ok();
10106        let local_var_error = ResponseContent {
10107            status: local_var_status,
10108            content: local_var_content,
10109            entity: local_var_entity,
10110        };
10111        Err(Error::ResponseError(local_var_error))
10112    }
10113}
10114
10115/// Retrieve a prefix object.
10116pub async fn ipam_prefixes_retrieve(
10117    configuration: &configuration::Configuration,
10118    id: &str,
10119    format: Option<&str>,
10120    depth: Option<i32>,
10121    exclude_m2m: Option<bool>,
10122) -> Result<crate::models::Prefix, Error<IpamPrefixesRetrieveError>> {
10123    let local_var_configuration = configuration;
10124
10125    let local_var_client = &local_var_configuration.client;
10126
10127    let local_var_uri_str = format!(
10128        "{}/ipam/prefixes/{id}/",
10129        local_var_configuration.base_path,
10130        id = crate::apis::urlencode(id)
10131    );
10132    let mut local_var_req_builder =
10133        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10134
10135    if let Some(ref local_var_str) = format {
10136        local_var_req_builder =
10137            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10138    }
10139    if let Some(ref local_var_str) = depth {
10140        local_var_req_builder =
10141            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10142    }
10143    if let Some(ref local_var_str) = exclude_m2m {
10144        local_var_req_builder =
10145            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10146    }
10147    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10148        local_var_req_builder =
10149            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10150    }
10151    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10152        let local_var_key = local_var_apikey.key.clone();
10153        let local_var_value = match local_var_apikey.prefix {
10154            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10155            None => local_var_key,
10156        };
10157        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10158    };
10159
10160    let local_var_req = local_var_req_builder.build()?;
10161    let local_var_resp = local_var_client.execute(local_var_req).await?;
10162
10163    let local_var_status = local_var_resp.status();
10164    let local_var_content = local_var_resp.text().await?;
10165
10166    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10167        serde_json::from_str(&local_var_content).map_err(Error::from)
10168    } else {
10169        let local_var_entity: Option<IpamPrefixesRetrieveError> =
10170            serde_json::from_str(&local_var_content).ok();
10171        let local_var_error = ResponseContent {
10172            status: local_var_status,
10173            content: local_var_content,
10174            entity: local_var_entity,
10175        };
10176        Err(Error::ResponseError(local_var_error))
10177    }
10178}
10179
10180/// Update a prefix object.
10181pub async fn ipam_prefixes_update(
10182    configuration: &configuration::Configuration,
10183    id: &str,
10184    writable_prefix_request: crate::models::WritablePrefixRequest,
10185    format: Option<&str>,
10186) -> Result<crate::models::Prefix, Error<IpamPrefixesUpdateError>> {
10187    let local_var_configuration = configuration;
10188
10189    let local_var_client = &local_var_configuration.client;
10190
10191    let local_var_uri_str = format!(
10192        "{}/ipam/prefixes/{id}/",
10193        local_var_configuration.base_path,
10194        id = crate::apis::urlencode(id)
10195    );
10196    let mut local_var_req_builder =
10197        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10198
10199    if let Some(ref local_var_str) = format {
10200        local_var_req_builder =
10201            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10202    }
10203    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10204        local_var_req_builder =
10205            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10206    }
10207    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10208        let local_var_key = local_var_apikey.key.clone();
10209        let local_var_value = match local_var_apikey.prefix {
10210            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10211            None => local_var_key,
10212        };
10213        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10214    };
10215    local_var_req_builder = local_var_req_builder.json(&writable_prefix_request);
10216
10217    let local_var_req = local_var_req_builder.build()?;
10218    let local_var_resp = local_var_client.execute(local_var_req).await?;
10219
10220    let local_var_status = local_var_resp.status();
10221    let local_var_content = local_var_resp.text().await?;
10222
10223    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10224        serde_json::from_str(&local_var_content).map_err(Error::from)
10225    } else {
10226        let local_var_entity: Option<IpamPrefixesUpdateError> =
10227            serde_json::from_str(&local_var_content).ok();
10228        let local_var_error = ResponseContent {
10229            status: local_var_status,
10230            content: local_var_content,
10231            entity: local_var_entity,
10232        };
10233        Err(Error::ResponseError(local_var_error))
10234    }
10235}
10236
10237/// Destroy a list of RIR objects.
10238pub async fn ipam_rirs_bulk_destroy(
10239    configuration: &configuration::Configuration,
10240    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
10241    format: Option<&str>,
10242) -> Result<(), Error<IpamRirsBulkDestroyError>> {
10243    let local_var_configuration = configuration;
10244
10245    let local_var_client = &local_var_configuration.client;
10246
10247    let local_var_uri_str = format!("{}/ipam/rirs/", local_var_configuration.base_path);
10248    let mut local_var_req_builder =
10249        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10250
10251    if let Some(ref local_var_str) = format {
10252        local_var_req_builder =
10253            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10254    }
10255    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10256        local_var_req_builder =
10257            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10258    }
10259    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10260        let local_var_key = local_var_apikey.key.clone();
10261        let local_var_value = match local_var_apikey.prefix {
10262            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10263            None => local_var_key,
10264        };
10265        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10266    };
10267    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
10268
10269    let local_var_req = local_var_req_builder.build()?;
10270    let local_var_resp = local_var_client.execute(local_var_req).await?;
10271
10272    let local_var_status = local_var_resp.status();
10273    let local_var_content = local_var_resp.text().await?;
10274
10275    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10276        Ok(())
10277    } else {
10278        let local_var_entity: Option<IpamRirsBulkDestroyError> =
10279            serde_json::from_str(&local_var_content).ok();
10280        let local_var_error = ResponseContent {
10281            status: local_var_status,
10282            content: local_var_content,
10283            entity: local_var_entity,
10284        };
10285        Err(Error::ResponseError(local_var_error))
10286    }
10287}
10288
10289/// Partial update a list of RIR objects.
10290pub async fn ipam_rirs_bulk_partial_update(
10291    configuration: &configuration::Configuration,
10292    patched_bulk_writable_rir_request: Vec<crate::models::PatchedBulkWritableRirRequest>,
10293    format: Option<&str>,
10294) -> Result<Vec<crate::models::Rir>, Error<IpamRirsBulkPartialUpdateError>> {
10295    let local_var_configuration = configuration;
10296
10297    let local_var_client = &local_var_configuration.client;
10298
10299    let local_var_uri_str = format!("{}/ipam/rirs/", local_var_configuration.base_path);
10300    let mut local_var_req_builder =
10301        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10302
10303    if let Some(ref local_var_str) = format {
10304        local_var_req_builder =
10305            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10306    }
10307    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10308        local_var_req_builder =
10309            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10310    }
10311    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10312        let local_var_key = local_var_apikey.key.clone();
10313        let local_var_value = match local_var_apikey.prefix {
10314            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10315            None => local_var_key,
10316        };
10317        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10318    };
10319    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_rir_request);
10320
10321    let local_var_req = local_var_req_builder.build()?;
10322    let local_var_resp = local_var_client.execute(local_var_req).await?;
10323
10324    let local_var_status = local_var_resp.status();
10325    let local_var_content = local_var_resp.text().await?;
10326
10327    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10328        serde_json::from_str(&local_var_content).map_err(Error::from)
10329    } else {
10330        let local_var_entity: Option<IpamRirsBulkPartialUpdateError> =
10331            serde_json::from_str(&local_var_content).ok();
10332        let local_var_error = ResponseContent {
10333            status: local_var_status,
10334            content: local_var_content,
10335            entity: local_var_entity,
10336        };
10337        Err(Error::ResponseError(local_var_error))
10338    }
10339}
10340
10341/// Update a list of RIR objects.
10342pub async fn ipam_rirs_bulk_update(
10343    configuration: &configuration::Configuration,
10344    bulk_writable_rir_request: Vec<crate::models::BulkWritableRirRequest>,
10345    format: Option<&str>,
10346) -> Result<Vec<crate::models::Rir>, Error<IpamRirsBulkUpdateError>> {
10347    let local_var_configuration = configuration;
10348
10349    let local_var_client = &local_var_configuration.client;
10350
10351    let local_var_uri_str = format!("{}/ipam/rirs/", local_var_configuration.base_path);
10352    let mut local_var_req_builder =
10353        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10354
10355    if let Some(ref local_var_str) = format {
10356        local_var_req_builder =
10357            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10358    }
10359    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10360        local_var_req_builder =
10361            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10362    }
10363    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10364        let local_var_key = local_var_apikey.key.clone();
10365        let local_var_value = match local_var_apikey.prefix {
10366            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10367            None => local_var_key,
10368        };
10369        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10370    };
10371    local_var_req_builder = local_var_req_builder.json(&bulk_writable_rir_request);
10372
10373    let local_var_req = local_var_req_builder.build()?;
10374    let local_var_resp = local_var_client.execute(local_var_req).await?;
10375
10376    let local_var_status = local_var_resp.status();
10377    let local_var_content = local_var_resp.text().await?;
10378
10379    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10380        serde_json::from_str(&local_var_content).map_err(Error::from)
10381    } else {
10382        let local_var_entity: Option<IpamRirsBulkUpdateError> =
10383            serde_json::from_str(&local_var_content).ok();
10384        let local_var_error = ResponseContent {
10385            status: local_var_status,
10386            content: local_var_content,
10387            entity: local_var_entity,
10388        };
10389        Err(Error::ResponseError(local_var_error))
10390    }
10391}
10392
10393/// Create one or more RIR objects.
10394pub async fn ipam_rirs_create(
10395    configuration: &configuration::Configuration,
10396    rir_request: crate::models::RirRequest,
10397    format: Option<&str>,
10398) -> Result<crate::models::Rir, Error<IpamRirsCreateError>> {
10399    let local_var_configuration = configuration;
10400
10401    let local_var_client = &local_var_configuration.client;
10402
10403    let local_var_uri_str = format!("{}/ipam/rirs/", local_var_configuration.base_path);
10404    let mut local_var_req_builder =
10405        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10406
10407    if let Some(ref local_var_str) = format {
10408        local_var_req_builder =
10409            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10410    }
10411    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10412        local_var_req_builder =
10413            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10414    }
10415    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10416        let local_var_key = local_var_apikey.key.clone();
10417        let local_var_value = match local_var_apikey.prefix {
10418            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10419            None => local_var_key,
10420        };
10421        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10422    };
10423    local_var_req_builder = local_var_req_builder.json(&rir_request);
10424
10425    let local_var_req = local_var_req_builder.build()?;
10426    let local_var_resp = local_var_client.execute(local_var_req).await?;
10427
10428    let local_var_status = local_var_resp.status();
10429    let local_var_content = local_var_resp.text().await?;
10430
10431    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10432        serde_json::from_str(&local_var_content).map_err(Error::from)
10433    } else {
10434        let local_var_entity: Option<IpamRirsCreateError> =
10435            serde_json::from_str(&local_var_content).ok();
10436        let local_var_error = ResponseContent {
10437            status: local_var_status,
10438            content: local_var_content,
10439            entity: local_var_entity,
10440        };
10441        Err(Error::ResponseError(local_var_error))
10442    }
10443}
10444
10445/// Destroy a RIR object.
10446pub async fn ipam_rirs_destroy(
10447    configuration: &configuration::Configuration,
10448    id: &str,
10449    format: Option<&str>,
10450) -> Result<(), Error<IpamRirsDestroyError>> {
10451    let local_var_configuration = configuration;
10452
10453    let local_var_client = &local_var_configuration.client;
10454
10455    let local_var_uri_str = format!(
10456        "{}/ipam/rirs/{id}/",
10457        local_var_configuration.base_path,
10458        id = crate::apis::urlencode(id)
10459    );
10460    let mut local_var_req_builder =
10461        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10462
10463    if let Some(ref local_var_str) = format {
10464        local_var_req_builder =
10465            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10466    }
10467    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10468        local_var_req_builder =
10469            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10470    }
10471    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10472        let local_var_key = local_var_apikey.key.clone();
10473        let local_var_value = match local_var_apikey.prefix {
10474            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10475            None => local_var_key,
10476        };
10477        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10478    };
10479
10480    let local_var_req = local_var_req_builder.build()?;
10481    let local_var_resp = local_var_client.execute(local_var_req).await?;
10482
10483    let local_var_status = local_var_resp.status();
10484    let local_var_content = local_var_resp.text().await?;
10485
10486    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10487        Ok(())
10488    } else {
10489        let local_var_entity: Option<IpamRirsDestroyError> =
10490            serde_json::from_str(&local_var_content).ok();
10491        let local_var_error = ResponseContent {
10492            status: local_var_status,
10493            content: local_var_content,
10494            entity: local_var_entity,
10495        };
10496        Err(Error::ResponseError(local_var_error))
10497    }
10498}
10499
10500/// Retrieve a list of RIR objects.
10501pub async fn ipam_rirs_list(
10502    configuration: &configuration::Configuration,
10503    contacts: Option<Vec<String>>,
10504    contacts__isnull: Option<bool>,
10505    contacts__n: Option<Vec<String>>,
10506    created: Option<Vec<String>>,
10507    created__gt: Option<Vec<String>>,
10508    created__gte: Option<Vec<String>>,
10509    created__isnull: Option<bool>,
10510    created__lt: Option<Vec<String>>,
10511    created__lte: Option<Vec<String>>,
10512    created__n: Option<Vec<String>>,
10513    description: Option<Vec<String>>,
10514    description__ic: Option<Vec<String>>,
10515    description__ie: Option<Vec<String>>,
10516    description__iew: Option<Vec<String>>,
10517    description__ire: Option<Vec<String>>,
10518    description__isw: Option<Vec<String>>,
10519    description__n: Option<Vec<String>>,
10520    description__nic: Option<Vec<String>>,
10521    description__nie: Option<Vec<String>>,
10522    description__niew: Option<Vec<String>>,
10523    description__nire: Option<Vec<String>>,
10524    description__nisw: Option<Vec<String>>,
10525    description__nre: Option<Vec<String>>,
10526    description__re: Option<Vec<String>>,
10527    dynamic_groups: Option<Vec<String>>,
10528    dynamic_groups__n: Option<Vec<String>>,
10529    format: Option<&str>,
10530    id: Option<Vec<uuid::Uuid>>,
10531    id__n: Option<Vec<uuid::Uuid>>,
10532    is_private: Option<bool>,
10533    last_updated: Option<Vec<String>>,
10534    last_updated__gt: Option<Vec<String>>,
10535    last_updated__gte: Option<Vec<String>>,
10536    last_updated__isnull: Option<bool>,
10537    last_updated__lt: Option<Vec<String>>,
10538    last_updated__lte: Option<Vec<String>>,
10539    last_updated__n: Option<Vec<String>>,
10540    limit: Option<i32>,
10541    name: Option<Vec<String>>,
10542    name__ic: Option<Vec<String>>,
10543    name__ie: Option<Vec<String>>,
10544    name__iew: Option<Vec<String>>,
10545    name__ire: Option<Vec<String>>,
10546    name__isw: Option<Vec<String>>,
10547    name__n: Option<Vec<String>>,
10548    name__nic: Option<Vec<String>>,
10549    name__nie: Option<Vec<String>>,
10550    name__niew: Option<Vec<String>>,
10551    name__nire: Option<Vec<String>>,
10552    name__nisw: Option<Vec<String>>,
10553    name__nre: Option<Vec<String>>,
10554    name__re: Option<Vec<String>>,
10555    offset: Option<i32>,
10556    q: Option<&str>,
10557    sort: Option<&str>,
10558    teams: Option<Vec<String>>,
10559    teams__isnull: Option<bool>,
10560    teams__n: Option<Vec<String>>,
10561    depth: Option<i32>,
10562    exclude_m2m: Option<bool>,
10563) -> Result<crate::models::PaginatedRirList, Error<IpamRirsListError>> {
10564    let local_var_configuration = configuration;
10565
10566    let local_var_client = &local_var_configuration.client;
10567
10568    let local_var_uri_str = format!("{}/ipam/rirs/", local_var_configuration.base_path);
10569    let mut local_var_req_builder =
10570        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10571
10572    if let Some(ref local_var_str) = contacts {
10573        local_var_req_builder = match "multi" {
10574            "multi" => local_var_req_builder.query(
10575                &local_var_str
10576                    .into_iter()
10577                    .map(|p| ("contacts".to_owned(), p.to_string()))
10578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10579            ),
10580            _ => local_var_req_builder.query(&[(
10581                "contacts",
10582                &local_var_str
10583                    .into_iter()
10584                    .map(|p| p.to_string())
10585                    .collect::<Vec<String>>()
10586                    .join(",")
10587                    .to_string(),
10588            )]),
10589        };
10590    }
10591    if let Some(ref local_var_str) = contacts__isnull {
10592        local_var_req_builder =
10593            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
10594    }
10595    if let Some(ref local_var_str) = contacts__n {
10596        local_var_req_builder = match "multi" {
10597            "multi" => local_var_req_builder.query(
10598                &local_var_str
10599                    .into_iter()
10600                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
10601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10602            ),
10603            _ => local_var_req_builder.query(&[(
10604                "contacts__n",
10605                &local_var_str
10606                    .into_iter()
10607                    .map(|p| p.to_string())
10608                    .collect::<Vec<String>>()
10609                    .join(",")
10610                    .to_string(),
10611            )]),
10612        };
10613    }
10614    if let Some(ref local_var_str) = created {
10615        local_var_req_builder = match "multi" {
10616            "multi" => local_var_req_builder.query(
10617                &local_var_str
10618                    .into_iter()
10619                    .map(|p| ("created".to_owned(), p.to_string()))
10620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10621            ),
10622            _ => local_var_req_builder.query(&[(
10623                "created",
10624                &local_var_str
10625                    .into_iter()
10626                    .map(|p| p.to_string())
10627                    .collect::<Vec<String>>()
10628                    .join(",")
10629                    .to_string(),
10630            )]),
10631        };
10632    }
10633    if let Some(ref local_var_str) = created__gt {
10634        local_var_req_builder = match "multi" {
10635            "multi" => local_var_req_builder.query(
10636                &local_var_str
10637                    .into_iter()
10638                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10640            ),
10641            _ => local_var_req_builder.query(&[(
10642                "created__gt",
10643                &local_var_str
10644                    .into_iter()
10645                    .map(|p| p.to_string())
10646                    .collect::<Vec<String>>()
10647                    .join(",")
10648                    .to_string(),
10649            )]),
10650        };
10651    }
10652    if let Some(ref local_var_str) = created__gte {
10653        local_var_req_builder = match "multi" {
10654            "multi" => local_var_req_builder.query(
10655                &local_var_str
10656                    .into_iter()
10657                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10659            ),
10660            _ => local_var_req_builder.query(&[(
10661                "created__gte",
10662                &local_var_str
10663                    .into_iter()
10664                    .map(|p| p.to_string())
10665                    .collect::<Vec<String>>()
10666                    .join(",")
10667                    .to_string(),
10668            )]),
10669        };
10670    }
10671    if let Some(ref local_var_str) = created__isnull {
10672        local_var_req_builder =
10673            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
10674    }
10675    if let Some(ref local_var_str) = created__lt {
10676        local_var_req_builder = match "multi" {
10677            "multi" => local_var_req_builder.query(
10678                &local_var_str
10679                    .into_iter()
10680                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10682            ),
10683            _ => local_var_req_builder.query(&[(
10684                "created__lt",
10685                &local_var_str
10686                    .into_iter()
10687                    .map(|p| p.to_string())
10688                    .collect::<Vec<String>>()
10689                    .join(",")
10690                    .to_string(),
10691            )]),
10692        };
10693    }
10694    if let Some(ref local_var_str) = created__lte {
10695        local_var_req_builder = match "multi" {
10696            "multi" => local_var_req_builder.query(
10697                &local_var_str
10698                    .into_iter()
10699                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10701            ),
10702            _ => local_var_req_builder.query(&[(
10703                "created__lte",
10704                &local_var_str
10705                    .into_iter()
10706                    .map(|p| p.to_string())
10707                    .collect::<Vec<String>>()
10708                    .join(",")
10709                    .to_string(),
10710            )]),
10711        };
10712    }
10713    if let Some(ref local_var_str) = created__n {
10714        local_var_req_builder = match "multi" {
10715            "multi" => local_var_req_builder.query(
10716                &local_var_str
10717                    .into_iter()
10718                    .map(|p| ("created__n".to_owned(), p.to_string()))
10719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10720            ),
10721            _ => local_var_req_builder.query(&[(
10722                "created__n",
10723                &local_var_str
10724                    .into_iter()
10725                    .map(|p| p.to_string())
10726                    .collect::<Vec<String>>()
10727                    .join(",")
10728                    .to_string(),
10729            )]),
10730        };
10731    }
10732    if let Some(ref local_var_str) = description {
10733        local_var_req_builder = match "multi" {
10734            "multi" => local_var_req_builder.query(
10735                &local_var_str
10736                    .into_iter()
10737                    .map(|p| ("description".to_owned(), p.to_string()))
10738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10739            ),
10740            _ => local_var_req_builder.query(&[(
10741                "description",
10742                &local_var_str
10743                    .into_iter()
10744                    .map(|p| p.to_string())
10745                    .collect::<Vec<String>>()
10746                    .join(",")
10747                    .to_string(),
10748            )]),
10749        };
10750    }
10751    if let Some(ref local_var_str) = description__ic {
10752        local_var_req_builder = match "multi" {
10753            "multi" => local_var_req_builder.query(
10754                &local_var_str
10755                    .into_iter()
10756                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10758            ),
10759            _ => local_var_req_builder.query(&[(
10760                "description__ic",
10761                &local_var_str
10762                    .into_iter()
10763                    .map(|p| p.to_string())
10764                    .collect::<Vec<String>>()
10765                    .join(",")
10766                    .to_string(),
10767            )]),
10768        };
10769    }
10770    if let Some(ref local_var_str) = description__ie {
10771        local_var_req_builder = match "multi" {
10772            "multi" => local_var_req_builder.query(
10773                &local_var_str
10774                    .into_iter()
10775                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10777            ),
10778            _ => local_var_req_builder.query(&[(
10779                "description__ie",
10780                &local_var_str
10781                    .into_iter()
10782                    .map(|p| p.to_string())
10783                    .collect::<Vec<String>>()
10784                    .join(",")
10785                    .to_string(),
10786            )]),
10787        };
10788    }
10789    if let Some(ref local_var_str) = description__iew {
10790        local_var_req_builder = match "multi" {
10791            "multi" => local_var_req_builder.query(
10792                &local_var_str
10793                    .into_iter()
10794                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10796            ),
10797            _ => local_var_req_builder.query(&[(
10798                "description__iew",
10799                &local_var_str
10800                    .into_iter()
10801                    .map(|p| p.to_string())
10802                    .collect::<Vec<String>>()
10803                    .join(",")
10804                    .to_string(),
10805            )]),
10806        };
10807    }
10808    if let Some(ref local_var_str) = description__ire {
10809        local_var_req_builder = match "multi" {
10810            "multi" => local_var_req_builder.query(
10811                &local_var_str
10812                    .into_iter()
10813                    .map(|p| ("description__ire".to_owned(), p.to_string()))
10814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10815            ),
10816            _ => local_var_req_builder.query(&[(
10817                "description__ire",
10818                &local_var_str
10819                    .into_iter()
10820                    .map(|p| p.to_string())
10821                    .collect::<Vec<String>>()
10822                    .join(",")
10823                    .to_string(),
10824            )]),
10825        };
10826    }
10827    if let Some(ref local_var_str) = description__isw {
10828        local_var_req_builder = match "multi" {
10829            "multi" => local_var_req_builder.query(
10830                &local_var_str
10831                    .into_iter()
10832                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10834            ),
10835            _ => local_var_req_builder.query(&[(
10836                "description__isw",
10837                &local_var_str
10838                    .into_iter()
10839                    .map(|p| p.to_string())
10840                    .collect::<Vec<String>>()
10841                    .join(",")
10842                    .to_string(),
10843            )]),
10844        };
10845    }
10846    if let Some(ref local_var_str) = description__n {
10847        local_var_req_builder = match "multi" {
10848            "multi" => local_var_req_builder.query(
10849                &local_var_str
10850                    .into_iter()
10851                    .map(|p| ("description__n".to_owned(), p.to_string()))
10852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10853            ),
10854            _ => local_var_req_builder.query(&[(
10855                "description__n",
10856                &local_var_str
10857                    .into_iter()
10858                    .map(|p| p.to_string())
10859                    .collect::<Vec<String>>()
10860                    .join(",")
10861                    .to_string(),
10862            )]),
10863        };
10864    }
10865    if let Some(ref local_var_str) = description__nic {
10866        local_var_req_builder = match "multi" {
10867            "multi" => local_var_req_builder.query(
10868                &local_var_str
10869                    .into_iter()
10870                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10872            ),
10873            _ => local_var_req_builder.query(&[(
10874                "description__nic",
10875                &local_var_str
10876                    .into_iter()
10877                    .map(|p| p.to_string())
10878                    .collect::<Vec<String>>()
10879                    .join(",")
10880                    .to_string(),
10881            )]),
10882        };
10883    }
10884    if let Some(ref local_var_str) = description__nie {
10885        local_var_req_builder = match "multi" {
10886            "multi" => local_var_req_builder.query(
10887                &local_var_str
10888                    .into_iter()
10889                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10891            ),
10892            _ => local_var_req_builder.query(&[(
10893                "description__nie",
10894                &local_var_str
10895                    .into_iter()
10896                    .map(|p| p.to_string())
10897                    .collect::<Vec<String>>()
10898                    .join(",")
10899                    .to_string(),
10900            )]),
10901        };
10902    }
10903    if let Some(ref local_var_str) = description__niew {
10904        local_var_req_builder = match "multi" {
10905            "multi" => local_var_req_builder.query(
10906                &local_var_str
10907                    .into_iter()
10908                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10910            ),
10911            _ => local_var_req_builder.query(&[(
10912                "description__niew",
10913                &local_var_str
10914                    .into_iter()
10915                    .map(|p| p.to_string())
10916                    .collect::<Vec<String>>()
10917                    .join(",")
10918                    .to_string(),
10919            )]),
10920        };
10921    }
10922    if let Some(ref local_var_str) = description__nire {
10923        local_var_req_builder = match "multi" {
10924            "multi" => local_var_req_builder.query(
10925                &local_var_str
10926                    .into_iter()
10927                    .map(|p| ("description__nire".to_owned(), p.to_string()))
10928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10929            ),
10930            _ => local_var_req_builder.query(&[(
10931                "description__nire",
10932                &local_var_str
10933                    .into_iter()
10934                    .map(|p| p.to_string())
10935                    .collect::<Vec<String>>()
10936                    .join(",")
10937                    .to_string(),
10938            )]),
10939        };
10940    }
10941    if let Some(ref local_var_str) = description__nisw {
10942        local_var_req_builder = match "multi" {
10943            "multi" => local_var_req_builder.query(
10944                &local_var_str
10945                    .into_iter()
10946                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10948            ),
10949            _ => local_var_req_builder.query(&[(
10950                "description__nisw",
10951                &local_var_str
10952                    .into_iter()
10953                    .map(|p| p.to_string())
10954                    .collect::<Vec<String>>()
10955                    .join(",")
10956                    .to_string(),
10957            )]),
10958        };
10959    }
10960    if let Some(ref local_var_str) = description__nre {
10961        local_var_req_builder = match "multi" {
10962            "multi" => local_var_req_builder.query(
10963                &local_var_str
10964                    .into_iter()
10965                    .map(|p| ("description__nre".to_owned(), p.to_string()))
10966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10967            ),
10968            _ => local_var_req_builder.query(&[(
10969                "description__nre",
10970                &local_var_str
10971                    .into_iter()
10972                    .map(|p| p.to_string())
10973                    .collect::<Vec<String>>()
10974                    .join(",")
10975                    .to_string(),
10976            )]),
10977        };
10978    }
10979    if let Some(ref local_var_str) = description__re {
10980        local_var_req_builder = match "multi" {
10981            "multi" => local_var_req_builder.query(
10982                &local_var_str
10983                    .into_iter()
10984                    .map(|p| ("description__re".to_owned(), p.to_string()))
10985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10986            ),
10987            _ => local_var_req_builder.query(&[(
10988                "description__re",
10989                &local_var_str
10990                    .into_iter()
10991                    .map(|p| p.to_string())
10992                    .collect::<Vec<String>>()
10993                    .join(",")
10994                    .to_string(),
10995            )]),
10996        };
10997    }
10998    if let Some(ref local_var_str) = dynamic_groups {
10999        local_var_req_builder = match "multi" {
11000            "multi" => local_var_req_builder.query(
11001                &local_var_str
11002                    .into_iter()
11003                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
11004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11005            ),
11006            _ => local_var_req_builder.query(&[(
11007                "dynamic_groups",
11008                &local_var_str
11009                    .into_iter()
11010                    .map(|p| p.to_string())
11011                    .collect::<Vec<String>>()
11012                    .join(",")
11013                    .to_string(),
11014            )]),
11015        };
11016    }
11017    if let Some(ref local_var_str) = dynamic_groups__n {
11018        local_var_req_builder = match "multi" {
11019            "multi" => local_var_req_builder.query(
11020                &local_var_str
11021                    .into_iter()
11022                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
11023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11024            ),
11025            _ => local_var_req_builder.query(&[(
11026                "dynamic_groups__n",
11027                &local_var_str
11028                    .into_iter()
11029                    .map(|p| p.to_string())
11030                    .collect::<Vec<String>>()
11031                    .join(",")
11032                    .to_string(),
11033            )]),
11034        };
11035    }
11036    if let Some(ref local_var_str) = format {
11037        local_var_req_builder =
11038            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11039    }
11040    if let Some(ref local_var_str) = id {
11041        local_var_req_builder = match "multi" {
11042            "multi" => local_var_req_builder.query(
11043                &local_var_str
11044                    .into_iter()
11045                    .map(|p| ("id".to_owned(), p.to_string()))
11046                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11047            ),
11048            _ => local_var_req_builder.query(&[(
11049                "id",
11050                &local_var_str
11051                    .into_iter()
11052                    .map(|p| p.to_string())
11053                    .collect::<Vec<String>>()
11054                    .join(",")
11055                    .to_string(),
11056            )]),
11057        };
11058    }
11059    if let Some(ref local_var_str) = id__n {
11060        local_var_req_builder = match "multi" {
11061            "multi" => local_var_req_builder.query(
11062                &local_var_str
11063                    .into_iter()
11064                    .map(|p| ("id__n".to_owned(), p.to_string()))
11065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11066            ),
11067            _ => local_var_req_builder.query(&[(
11068                "id__n",
11069                &local_var_str
11070                    .into_iter()
11071                    .map(|p| p.to_string())
11072                    .collect::<Vec<String>>()
11073                    .join(",")
11074                    .to_string(),
11075            )]),
11076        };
11077    }
11078    if let Some(ref local_var_str) = is_private {
11079        local_var_req_builder =
11080            local_var_req_builder.query(&[("is_private", &local_var_str.to_string())]);
11081    }
11082    if let Some(ref local_var_str) = last_updated {
11083        local_var_req_builder = match "multi" {
11084            "multi" => local_var_req_builder.query(
11085                &local_var_str
11086                    .into_iter()
11087                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11089            ),
11090            _ => local_var_req_builder.query(&[(
11091                "last_updated",
11092                &local_var_str
11093                    .into_iter()
11094                    .map(|p| p.to_string())
11095                    .collect::<Vec<String>>()
11096                    .join(",")
11097                    .to_string(),
11098            )]),
11099        };
11100    }
11101    if let Some(ref local_var_str) = last_updated__gt {
11102        local_var_req_builder = match "multi" {
11103            "multi" => local_var_req_builder.query(
11104                &local_var_str
11105                    .into_iter()
11106                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11108            ),
11109            _ => local_var_req_builder.query(&[(
11110                "last_updated__gt",
11111                &local_var_str
11112                    .into_iter()
11113                    .map(|p| p.to_string())
11114                    .collect::<Vec<String>>()
11115                    .join(",")
11116                    .to_string(),
11117            )]),
11118        };
11119    }
11120    if let Some(ref local_var_str) = last_updated__gte {
11121        local_var_req_builder = match "multi" {
11122            "multi" => local_var_req_builder.query(
11123                &local_var_str
11124                    .into_iter()
11125                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11127            ),
11128            _ => local_var_req_builder.query(&[(
11129                "last_updated__gte",
11130                &local_var_str
11131                    .into_iter()
11132                    .map(|p| p.to_string())
11133                    .collect::<Vec<String>>()
11134                    .join(",")
11135                    .to_string(),
11136            )]),
11137        };
11138    }
11139    if let Some(ref local_var_str) = last_updated__isnull {
11140        local_var_req_builder =
11141            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
11142    }
11143    if let Some(ref local_var_str) = last_updated__lt {
11144        local_var_req_builder = match "multi" {
11145            "multi" => local_var_req_builder.query(
11146                &local_var_str
11147                    .into_iter()
11148                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11150            ),
11151            _ => local_var_req_builder.query(&[(
11152                "last_updated__lt",
11153                &local_var_str
11154                    .into_iter()
11155                    .map(|p| p.to_string())
11156                    .collect::<Vec<String>>()
11157                    .join(",")
11158                    .to_string(),
11159            )]),
11160        };
11161    }
11162    if let Some(ref local_var_str) = last_updated__lte {
11163        local_var_req_builder = match "multi" {
11164            "multi" => local_var_req_builder.query(
11165                &local_var_str
11166                    .into_iter()
11167                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11169            ),
11170            _ => local_var_req_builder.query(&[(
11171                "last_updated__lte",
11172                &local_var_str
11173                    .into_iter()
11174                    .map(|p| p.to_string())
11175                    .collect::<Vec<String>>()
11176                    .join(",")
11177                    .to_string(),
11178            )]),
11179        };
11180    }
11181    if let Some(ref local_var_str) = last_updated__n {
11182        local_var_req_builder = match "multi" {
11183            "multi" => local_var_req_builder.query(
11184                &local_var_str
11185                    .into_iter()
11186                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11188            ),
11189            _ => local_var_req_builder.query(&[(
11190                "last_updated__n",
11191                &local_var_str
11192                    .into_iter()
11193                    .map(|p| p.to_string())
11194                    .collect::<Vec<String>>()
11195                    .join(",")
11196                    .to_string(),
11197            )]),
11198        };
11199    }
11200    if let Some(ref local_var_str) = limit {
11201        local_var_req_builder =
11202            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11203    }
11204    if let Some(ref local_var_str) = name {
11205        local_var_req_builder = match "multi" {
11206            "multi" => local_var_req_builder.query(
11207                &local_var_str
11208                    .into_iter()
11209                    .map(|p| ("name".to_owned(), p.to_string()))
11210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11211            ),
11212            _ => local_var_req_builder.query(&[(
11213                "name",
11214                &local_var_str
11215                    .into_iter()
11216                    .map(|p| p.to_string())
11217                    .collect::<Vec<String>>()
11218                    .join(",")
11219                    .to_string(),
11220            )]),
11221        };
11222    }
11223    if let Some(ref local_var_str) = name__ic {
11224        local_var_req_builder = match "multi" {
11225            "multi" => local_var_req_builder.query(
11226                &local_var_str
11227                    .into_iter()
11228                    .map(|p| ("name__ic".to_owned(), p.to_string()))
11229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11230            ),
11231            _ => local_var_req_builder.query(&[(
11232                "name__ic",
11233                &local_var_str
11234                    .into_iter()
11235                    .map(|p| p.to_string())
11236                    .collect::<Vec<String>>()
11237                    .join(",")
11238                    .to_string(),
11239            )]),
11240        };
11241    }
11242    if let Some(ref local_var_str) = name__ie {
11243        local_var_req_builder = match "multi" {
11244            "multi" => local_var_req_builder.query(
11245                &local_var_str
11246                    .into_iter()
11247                    .map(|p| ("name__ie".to_owned(), p.to_string()))
11248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11249            ),
11250            _ => local_var_req_builder.query(&[(
11251                "name__ie",
11252                &local_var_str
11253                    .into_iter()
11254                    .map(|p| p.to_string())
11255                    .collect::<Vec<String>>()
11256                    .join(",")
11257                    .to_string(),
11258            )]),
11259        };
11260    }
11261    if let Some(ref local_var_str) = name__iew {
11262        local_var_req_builder = match "multi" {
11263            "multi" => local_var_req_builder.query(
11264                &local_var_str
11265                    .into_iter()
11266                    .map(|p| ("name__iew".to_owned(), p.to_string()))
11267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11268            ),
11269            _ => local_var_req_builder.query(&[(
11270                "name__iew",
11271                &local_var_str
11272                    .into_iter()
11273                    .map(|p| p.to_string())
11274                    .collect::<Vec<String>>()
11275                    .join(",")
11276                    .to_string(),
11277            )]),
11278        };
11279    }
11280    if let Some(ref local_var_str) = name__ire {
11281        local_var_req_builder = match "multi" {
11282            "multi" => local_var_req_builder.query(
11283                &local_var_str
11284                    .into_iter()
11285                    .map(|p| ("name__ire".to_owned(), p.to_string()))
11286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11287            ),
11288            _ => local_var_req_builder.query(&[(
11289                "name__ire",
11290                &local_var_str
11291                    .into_iter()
11292                    .map(|p| p.to_string())
11293                    .collect::<Vec<String>>()
11294                    .join(",")
11295                    .to_string(),
11296            )]),
11297        };
11298    }
11299    if let Some(ref local_var_str) = name__isw {
11300        local_var_req_builder = match "multi" {
11301            "multi" => local_var_req_builder.query(
11302                &local_var_str
11303                    .into_iter()
11304                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11306            ),
11307            _ => local_var_req_builder.query(&[(
11308                "name__isw",
11309                &local_var_str
11310                    .into_iter()
11311                    .map(|p| p.to_string())
11312                    .collect::<Vec<String>>()
11313                    .join(",")
11314                    .to_string(),
11315            )]),
11316        };
11317    }
11318    if let Some(ref local_var_str) = name__n {
11319        local_var_req_builder = match "multi" {
11320            "multi" => local_var_req_builder.query(
11321                &local_var_str
11322                    .into_iter()
11323                    .map(|p| ("name__n".to_owned(), p.to_string()))
11324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11325            ),
11326            _ => local_var_req_builder.query(&[(
11327                "name__n",
11328                &local_var_str
11329                    .into_iter()
11330                    .map(|p| p.to_string())
11331                    .collect::<Vec<String>>()
11332                    .join(",")
11333                    .to_string(),
11334            )]),
11335        };
11336    }
11337    if let Some(ref local_var_str) = name__nic {
11338        local_var_req_builder = match "multi" {
11339            "multi" => local_var_req_builder.query(
11340                &local_var_str
11341                    .into_iter()
11342                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11344            ),
11345            _ => local_var_req_builder.query(&[(
11346                "name__nic",
11347                &local_var_str
11348                    .into_iter()
11349                    .map(|p| p.to_string())
11350                    .collect::<Vec<String>>()
11351                    .join(",")
11352                    .to_string(),
11353            )]),
11354        };
11355    }
11356    if let Some(ref local_var_str) = name__nie {
11357        local_var_req_builder = match "multi" {
11358            "multi" => local_var_req_builder.query(
11359                &local_var_str
11360                    .into_iter()
11361                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11363            ),
11364            _ => local_var_req_builder.query(&[(
11365                "name__nie",
11366                &local_var_str
11367                    .into_iter()
11368                    .map(|p| p.to_string())
11369                    .collect::<Vec<String>>()
11370                    .join(",")
11371                    .to_string(),
11372            )]),
11373        };
11374    }
11375    if let Some(ref local_var_str) = name__niew {
11376        local_var_req_builder = match "multi" {
11377            "multi" => local_var_req_builder.query(
11378                &local_var_str
11379                    .into_iter()
11380                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11382            ),
11383            _ => local_var_req_builder.query(&[(
11384                "name__niew",
11385                &local_var_str
11386                    .into_iter()
11387                    .map(|p| p.to_string())
11388                    .collect::<Vec<String>>()
11389                    .join(",")
11390                    .to_string(),
11391            )]),
11392        };
11393    }
11394    if let Some(ref local_var_str) = name__nire {
11395        local_var_req_builder = match "multi" {
11396            "multi" => local_var_req_builder.query(
11397                &local_var_str
11398                    .into_iter()
11399                    .map(|p| ("name__nire".to_owned(), p.to_string()))
11400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11401            ),
11402            _ => local_var_req_builder.query(&[(
11403                "name__nire",
11404                &local_var_str
11405                    .into_iter()
11406                    .map(|p| p.to_string())
11407                    .collect::<Vec<String>>()
11408                    .join(",")
11409                    .to_string(),
11410            )]),
11411        };
11412    }
11413    if let Some(ref local_var_str) = name__nisw {
11414        local_var_req_builder = match "multi" {
11415            "multi" => local_var_req_builder.query(
11416                &local_var_str
11417                    .into_iter()
11418                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11420            ),
11421            _ => local_var_req_builder.query(&[(
11422                "name__nisw",
11423                &local_var_str
11424                    .into_iter()
11425                    .map(|p| p.to_string())
11426                    .collect::<Vec<String>>()
11427                    .join(",")
11428                    .to_string(),
11429            )]),
11430        };
11431    }
11432    if let Some(ref local_var_str) = name__nre {
11433        local_var_req_builder = match "multi" {
11434            "multi" => local_var_req_builder.query(
11435                &local_var_str
11436                    .into_iter()
11437                    .map(|p| ("name__nre".to_owned(), p.to_string()))
11438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11439            ),
11440            _ => local_var_req_builder.query(&[(
11441                "name__nre",
11442                &local_var_str
11443                    .into_iter()
11444                    .map(|p| p.to_string())
11445                    .collect::<Vec<String>>()
11446                    .join(",")
11447                    .to_string(),
11448            )]),
11449        };
11450    }
11451    if let Some(ref local_var_str) = name__re {
11452        local_var_req_builder = match "multi" {
11453            "multi" => local_var_req_builder.query(
11454                &local_var_str
11455                    .into_iter()
11456                    .map(|p| ("name__re".to_owned(), p.to_string()))
11457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11458            ),
11459            _ => local_var_req_builder.query(&[(
11460                "name__re",
11461                &local_var_str
11462                    .into_iter()
11463                    .map(|p| p.to_string())
11464                    .collect::<Vec<String>>()
11465                    .join(",")
11466                    .to_string(),
11467            )]),
11468        };
11469    }
11470    if let Some(ref local_var_str) = offset {
11471        local_var_req_builder =
11472            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11473    }
11474    if let Some(ref local_var_str) = q {
11475        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11476    }
11477    if let Some(ref local_var_str) = sort {
11478        local_var_req_builder =
11479            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
11480    }
11481    if let Some(ref local_var_str) = teams {
11482        local_var_req_builder = match "multi" {
11483            "multi" => local_var_req_builder.query(
11484                &local_var_str
11485                    .into_iter()
11486                    .map(|p| ("teams".to_owned(), p.to_string()))
11487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11488            ),
11489            _ => local_var_req_builder.query(&[(
11490                "teams",
11491                &local_var_str
11492                    .into_iter()
11493                    .map(|p| p.to_string())
11494                    .collect::<Vec<String>>()
11495                    .join(",")
11496                    .to_string(),
11497            )]),
11498        };
11499    }
11500    if let Some(ref local_var_str) = teams__isnull {
11501        local_var_req_builder =
11502            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
11503    }
11504    if let Some(ref local_var_str) = teams__n {
11505        local_var_req_builder = match "multi" {
11506            "multi" => local_var_req_builder.query(
11507                &local_var_str
11508                    .into_iter()
11509                    .map(|p| ("teams__n".to_owned(), p.to_string()))
11510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11511            ),
11512            _ => local_var_req_builder.query(&[(
11513                "teams__n",
11514                &local_var_str
11515                    .into_iter()
11516                    .map(|p| p.to_string())
11517                    .collect::<Vec<String>>()
11518                    .join(",")
11519                    .to_string(),
11520            )]),
11521        };
11522    }
11523    if let Some(ref local_var_str) = depth {
11524        local_var_req_builder =
11525            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11526    }
11527    if let Some(ref local_var_str) = exclude_m2m {
11528        local_var_req_builder =
11529            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11530    }
11531    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11532        local_var_req_builder =
11533            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11534    }
11535    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11536        let local_var_key = local_var_apikey.key.clone();
11537        let local_var_value = match local_var_apikey.prefix {
11538            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11539            None => local_var_key,
11540        };
11541        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11542    };
11543
11544    let local_var_req = local_var_req_builder.build()?;
11545    let local_var_resp = local_var_client.execute(local_var_req).await?;
11546
11547    let local_var_status = local_var_resp.status();
11548    let local_var_content = local_var_resp.text().await?;
11549
11550    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11551        serde_json::from_str(&local_var_content).map_err(Error::from)
11552    } else {
11553        let local_var_entity: Option<IpamRirsListError> =
11554            serde_json::from_str(&local_var_content).ok();
11555        let local_var_error = ResponseContent {
11556            status: local_var_status,
11557            content: local_var_content,
11558            entity: local_var_entity,
11559        };
11560        Err(Error::ResponseError(local_var_error))
11561    }
11562}
11563
11564/// API methods for returning or creating notes on an object.
11565pub async fn ipam_rirs_notes_create(
11566    configuration: &configuration::Configuration,
11567    id: &str,
11568    note_input_request: crate::models::NoteInputRequest,
11569    format: Option<&str>,
11570) -> Result<crate::models::Note, Error<IpamRirsNotesCreateError>> {
11571    let local_var_configuration = configuration;
11572
11573    let local_var_client = &local_var_configuration.client;
11574
11575    let local_var_uri_str = format!(
11576        "{}/ipam/rirs/{id}/notes/",
11577        local_var_configuration.base_path,
11578        id = crate::apis::urlencode(id)
11579    );
11580    let mut local_var_req_builder =
11581        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11582
11583    if let Some(ref local_var_str) = format {
11584        local_var_req_builder =
11585            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11586    }
11587    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11588        local_var_req_builder =
11589            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11590    }
11591    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11592        let local_var_key = local_var_apikey.key.clone();
11593        let local_var_value = match local_var_apikey.prefix {
11594            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11595            None => local_var_key,
11596        };
11597        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11598    };
11599    local_var_req_builder = local_var_req_builder.json(&note_input_request);
11600
11601    let local_var_req = local_var_req_builder.build()?;
11602    let local_var_resp = local_var_client.execute(local_var_req).await?;
11603
11604    let local_var_status = local_var_resp.status();
11605    let local_var_content = local_var_resp.text().await?;
11606
11607    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11608        serde_json::from_str(&local_var_content).map_err(Error::from)
11609    } else {
11610        let local_var_entity: Option<IpamRirsNotesCreateError> =
11611            serde_json::from_str(&local_var_content).ok();
11612        let local_var_error = ResponseContent {
11613            status: local_var_status,
11614            content: local_var_content,
11615            entity: local_var_entity,
11616        };
11617        Err(Error::ResponseError(local_var_error))
11618    }
11619}
11620
11621/// API methods for returning or creating notes on an object.
11622pub async fn ipam_rirs_notes_list(
11623    configuration: &configuration::Configuration,
11624    id: &str,
11625    format: Option<&str>,
11626    limit: Option<i32>,
11627    offset: Option<i32>,
11628    depth: Option<i32>,
11629    exclude_m2m: Option<bool>,
11630) -> Result<crate::models::PaginatedNoteList, Error<IpamRirsNotesListError>> {
11631    let local_var_configuration = configuration;
11632
11633    let local_var_client = &local_var_configuration.client;
11634
11635    let local_var_uri_str = format!(
11636        "{}/ipam/rirs/{id}/notes/",
11637        local_var_configuration.base_path,
11638        id = crate::apis::urlencode(id)
11639    );
11640    let mut local_var_req_builder =
11641        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11642
11643    if let Some(ref local_var_str) = format {
11644        local_var_req_builder =
11645            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11646    }
11647    if let Some(ref local_var_str) = limit {
11648        local_var_req_builder =
11649            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11650    }
11651    if let Some(ref local_var_str) = offset {
11652        local_var_req_builder =
11653            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11654    }
11655    if let Some(ref local_var_str) = depth {
11656        local_var_req_builder =
11657            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11658    }
11659    if let Some(ref local_var_str) = exclude_m2m {
11660        local_var_req_builder =
11661            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11662    }
11663    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11664        local_var_req_builder =
11665            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11666    }
11667    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11668        let local_var_key = local_var_apikey.key.clone();
11669        let local_var_value = match local_var_apikey.prefix {
11670            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11671            None => local_var_key,
11672        };
11673        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11674    };
11675
11676    let local_var_req = local_var_req_builder.build()?;
11677    let local_var_resp = local_var_client.execute(local_var_req).await?;
11678
11679    let local_var_status = local_var_resp.status();
11680    let local_var_content = local_var_resp.text().await?;
11681
11682    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11683        serde_json::from_str(&local_var_content).map_err(Error::from)
11684    } else {
11685        let local_var_entity: Option<IpamRirsNotesListError> =
11686            serde_json::from_str(&local_var_content).ok();
11687        let local_var_error = ResponseContent {
11688            status: local_var_status,
11689            content: local_var_content,
11690            entity: local_var_entity,
11691        };
11692        Err(Error::ResponseError(local_var_error))
11693    }
11694}
11695
11696/// Partial update a RIR object.
11697pub async fn ipam_rirs_partial_update(
11698    configuration: &configuration::Configuration,
11699    id: &str,
11700    format: Option<&str>,
11701    patched_rir_request: Option<crate::models::PatchedRirRequest>,
11702) -> Result<crate::models::Rir, Error<IpamRirsPartialUpdateError>> {
11703    let local_var_configuration = configuration;
11704
11705    let local_var_client = &local_var_configuration.client;
11706
11707    let local_var_uri_str = format!(
11708        "{}/ipam/rirs/{id}/",
11709        local_var_configuration.base_path,
11710        id = crate::apis::urlencode(id)
11711    );
11712    let mut local_var_req_builder =
11713        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11714
11715    if let Some(ref local_var_str) = format {
11716        local_var_req_builder =
11717            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11718    }
11719    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11720        local_var_req_builder =
11721            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11722    }
11723    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11724        let local_var_key = local_var_apikey.key.clone();
11725        let local_var_value = match local_var_apikey.prefix {
11726            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11727            None => local_var_key,
11728        };
11729        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11730    };
11731    local_var_req_builder = local_var_req_builder.json(&patched_rir_request);
11732
11733    let local_var_req = local_var_req_builder.build()?;
11734    let local_var_resp = local_var_client.execute(local_var_req).await?;
11735
11736    let local_var_status = local_var_resp.status();
11737    let local_var_content = local_var_resp.text().await?;
11738
11739    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11740        serde_json::from_str(&local_var_content).map_err(Error::from)
11741    } else {
11742        let local_var_entity: Option<IpamRirsPartialUpdateError> =
11743            serde_json::from_str(&local_var_content).ok();
11744        let local_var_error = ResponseContent {
11745            status: local_var_status,
11746            content: local_var_content,
11747            entity: local_var_entity,
11748        };
11749        Err(Error::ResponseError(local_var_error))
11750    }
11751}
11752
11753/// Retrieve a RIR object.
11754pub async fn ipam_rirs_retrieve(
11755    configuration: &configuration::Configuration,
11756    id: &str,
11757    format: Option<&str>,
11758    depth: Option<i32>,
11759    exclude_m2m: Option<bool>,
11760) -> Result<crate::models::Rir, Error<IpamRirsRetrieveError>> {
11761    let local_var_configuration = configuration;
11762
11763    let local_var_client = &local_var_configuration.client;
11764
11765    let local_var_uri_str = format!(
11766        "{}/ipam/rirs/{id}/",
11767        local_var_configuration.base_path,
11768        id = crate::apis::urlencode(id)
11769    );
11770    let mut local_var_req_builder =
11771        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11772
11773    if let Some(ref local_var_str) = format {
11774        local_var_req_builder =
11775            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11776    }
11777    if let Some(ref local_var_str) = depth {
11778        local_var_req_builder =
11779            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11780    }
11781    if let Some(ref local_var_str) = exclude_m2m {
11782        local_var_req_builder =
11783            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11784    }
11785    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11786        local_var_req_builder =
11787            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11788    }
11789    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11790        let local_var_key = local_var_apikey.key.clone();
11791        let local_var_value = match local_var_apikey.prefix {
11792            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11793            None => local_var_key,
11794        };
11795        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11796    };
11797
11798    let local_var_req = local_var_req_builder.build()?;
11799    let local_var_resp = local_var_client.execute(local_var_req).await?;
11800
11801    let local_var_status = local_var_resp.status();
11802    let local_var_content = local_var_resp.text().await?;
11803
11804    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11805        serde_json::from_str(&local_var_content).map_err(Error::from)
11806    } else {
11807        let local_var_entity: Option<IpamRirsRetrieveError> =
11808            serde_json::from_str(&local_var_content).ok();
11809        let local_var_error = ResponseContent {
11810            status: local_var_status,
11811            content: local_var_content,
11812            entity: local_var_entity,
11813        };
11814        Err(Error::ResponseError(local_var_error))
11815    }
11816}
11817
11818/// Update a RIR object.
11819pub async fn ipam_rirs_update(
11820    configuration: &configuration::Configuration,
11821    id: &str,
11822    rir_request: crate::models::RirRequest,
11823    format: Option<&str>,
11824) -> Result<crate::models::Rir, Error<IpamRirsUpdateError>> {
11825    let local_var_configuration = configuration;
11826
11827    let local_var_client = &local_var_configuration.client;
11828
11829    let local_var_uri_str = format!(
11830        "{}/ipam/rirs/{id}/",
11831        local_var_configuration.base_path,
11832        id = crate::apis::urlencode(id)
11833    );
11834    let mut local_var_req_builder =
11835        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11836
11837    if let Some(ref local_var_str) = format {
11838        local_var_req_builder =
11839            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11840    }
11841    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11842        local_var_req_builder =
11843            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11844    }
11845    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11846        let local_var_key = local_var_apikey.key.clone();
11847        let local_var_value = match local_var_apikey.prefix {
11848            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11849            None => local_var_key,
11850        };
11851        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11852    };
11853    local_var_req_builder = local_var_req_builder.json(&rir_request);
11854
11855    let local_var_req = local_var_req_builder.build()?;
11856    let local_var_resp = local_var_client.execute(local_var_req).await?;
11857
11858    let local_var_status = local_var_resp.status();
11859    let local_var_content = local_var_resp.text().await?;
11860
11861    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11862        serde_json::from_str(&local_var_content).map_err(Error::from)
11863    } else {
11864        let local_var_entity: Option<IpamRirsUpdateError> =
11865            serde_json::from_str(&local_var_content).ok();
11866        let local_var_error = ResponseContent {
11867            status: local_var_status,
11868            content: local_var_content,
11869            entity: local_var_entity,
11870        };
11871        Err(Error::ResponseError(local_var_error))
11872    }
11873}
11874
11875/// Destroy a list of route target objects.
11876pub async fn ipam_route_targets_bulk_destroy(
11877    configuration: &configuration::Configuration,
11878    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
11879    format: Option<&str>,
11880) -> Result<(), Error<IpamRouteTargetsBulkDestroyError>> {
11881    let local_var_configuration = configuration;
11882
11883    let local_var_client = &local_var_configuration.client;
11884
11885    let local_var_uri_str = format!("{}/ipam/route-targets/", local_var_configuration.base_path);
11886    let mut local_var_req_builder =
11887        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11888
11889    if let Some(ref local_var_str) = format {
11890        local_var_req_builder =
11891            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11892    }
11893    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11894        local_var_req_builder =
11895            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11896    }
11897    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11898        let local_var_key = local_var_apikey.key.clone();
11899        let local_var_value = match local_var_apikey.prefix {
11900            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11901            None => local_var_key,
11902        };
11903        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11904    };
11905    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
11906
11907    let local_var_req = local_var_req_builder.build()?;
11908    let local_var_resp = local_var_client.execute(local_var_req).await?;
11909
11910    let local_var_status = local_var_resp.status();
11911    let local_var_content = local_var_resp.text().await?;
11912
11913    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11914        Ok(())
11915    } else {
11916        let local_var_entity: Option<IpamRouteTargetsBulkDestroyError> =
11917            serde_json::from_str(&local_var_content).ok();
11918        let local_var_error = ResponseContent {
11919            status: local_var_status,
11920            content: local_var_content,
11921            entity: local_var_entity,
11922        };
11923        Err(Error::ResponseError(local_var_error))
11924    }
11925}
11926
11927/// Partial update a list of route target objects.
11928pub async fn ipam_route_targets_bulk_partial_update(
11929    configuration: &configuration::Configuration,
11930    patched_bulk_writable_route_target_request: Vec<
11931        crate::models::PatchedBulkWritableRouteTargetRequest,
11932    >,
11933    format: Option<&str>,
11934) -> Result<Vec<crate::models::RouteTarget>, Error<IpamRouteTargetsBulkPartialUpdateError>> {
11935    let local_var_configuration = configuration;
11936
11937    let local_var_client = &local_var_configuration.client;
11938
11939    let local_var_uri_str = format!("{}/ipam/route-targets/", local_var_configuration.base_path);
11940    let mut local_var_req_builder =
11941        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11942
11943    if let Some(ref local_var_str) = format {
11944        local_var_req_builder =
11945            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11946    }
11947    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11948        local_var_req_builder =
11949            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11950    }
11951    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11952        let local_var_key = local_var_apikey.key.clone();
11953        let local_var_value = match local_var_apikey.prefix {
11954            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11955            None => local_var_key,
11956        };
11957        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11958    };
11959    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_route_target_request);
11960
11961    let local_var_req = local_var_req_builder.build()?;
11962    let local_var_resp = local_var_client.execute(local_var_req).await?;
11963
11964    let local_var_status = local_var_resp.status();
11965    let local_var_content = local_var_resp.text().await?;
11966
11967    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11968        serde_json::from_str(&local_var_content).map_err(Error::from)
11969    } else {
11970        let local_var_entity: Option<IpamRouteTargetsBulkPartialUpdateError> =
11971            serde_json::from_str(&local_var_content).ok();
11972        let local_var_error = ResponseContent {
11973            status: local_var_status,
11974            content: local_var_content,
11975            entity: local_var_entity,
11976        };
11977        Err(Error::ResponseError(local_var_error))
11978    }
11979}
11980
11981/// Update a list of route target objects.
11982pub async fn ipam_route_targets_bulk_update(
11983    configuration: &configuration::Configuration,
11984    bulk_writable_route_target_request: Vec<crate::models::BulkWritableRouteTargetRequest>,
11985    format: Option<&str>,
11986) -> Result<Vec<crate::models::RouteTarget>, Error<IpamRouteTargetsBulkUpdateError>> {
11987    let local_var_configuration = configuration;
11988
11989    let local_var_client = &local_var_configuration.client;
11990
11991    let local_var_uri_str = format!("{}/ipam/route-targets/", local_var_configuration.base_path);
11992    let mut local_var_req_builder =
11993        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11994
11995    if let Some(ref local_var_str) = format {
11996        local_var_req_builder =
11997            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11998    }
11999    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12000        local_var_req_builder =
12001            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12002    }
12003    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12004        let local_var_key = local_var_apikey.key.clone();
12005        let local_var_value = match local_var_apikey.prefix {
12006            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12007            None => local_var_key,
12008        };
12009        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12010    };
12011    local_var_req_builder = local_var_req_builder.json(&bulk_writable_route_target_request);
12012
12013    let local_var_req = local_var_req_builder.build()?;
12014    let local_var_resp = local_var_client.execute(local_var_req).await?;
12015
12016    let local_var_status = local_var_resp.status();
12017    let local_var_content = local_var_resp.text().await?;
12018
12019    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12020        serde_json::from_str(&local_var_content).map_err(Error::from)
12021    } else {
12022        let local_var_entity: Option<IpamRouteTargetsBulkUpdateError> =
12023            serde_json::from_str(&local_var_content).ok();
12024        let local_var_error = ResponseContent {
12025            status: local_var_status,
12026            content: local_var_content,
12027            entity: local_var_entity,
12028        };
12029        Err(Error::ResponseError(local_var_error))
12030    }
12031}
12032
12033/// Create one or more route target objects.
12034pub async fn ipam_route_targets_create(
12035    configuration: &configuration::Configuration,
12036    route_target_request: crate::models::RouteTargetRequest,
12037    format: Option<&str>,
12038) -> Result<crate::models::RouteTarget, Error<IpamRouteTargetsCreateError>> {
12039    let local_var_configuration = configuration;
12040
12041    let local_var_client = &local_var_configuration.client;
12042
12043    let local_var_uri_str = format!("{}/ipam/route-targets/", local_var_configuration.base_path);
12044    let mut local_var_req_builder =
12045        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
12046
12047    if let Some(ref local_var_str) = format {
12048        local_var_req_builder =
12049            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12050    }
12051    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12052        local_var_req_builder =
12053            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12054    }
12055    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12056        let local_var_key = local_var_apikey.key.clone();
12057        let local_var_value = match local_var_apikey.prefix {
12058            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12059            None => local_var_key,
12060        };
12061        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12062    };
12063    local_var_req_builder = local_var_req_builder.json(&route_target_request);
12064
12065    let local_var_req = local_var_req_builder.build()?;
12066    let local_var_resp = local_var_client.execute(local_var_req).await?;
12067
12068    let local_var_status = local_var_resp.status();
12069    let local_var_content = local_var_resp.text().await?;
12070
12071    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12072        serde_json::from_str(&local_var_content).map_err(Error::from)
12073    } else {
12074        let local_var_entity: Option<IpamRouteTargetsCreateError> =
12075            serde_json::from_str(&local_var_content).ok();
12076        let local_var_error = ResponseContent {
12077            status: local_var_status,
12078            content: local_var_content,
12079            entity: local_var_entity,
12080        };
12081        Err(Error::ResponseError(local_var_error))
12082    }
12083}
12084
12085/// Destroy a route target object.
12086pub async fn ipam_route_targets_destroy(
12087    configuration: &configuration::Configuration,
12088    id: &str,
12089    format: Option<&str>,
12090) -> Result<(), Error<IpamRouteTargetsDestroyError>> {
12091    let local_var_configuration = configuration;
12092
12093    let local_var_client = &local_var_configuration.client;
12094
12095    let local_var_uri_str = format!(
12096        "{}/ipam/route-targets/{id}/",
12097        local_var_configuration.base_path,
12098        id = crate::apis::urlencode(id)
12099    );
12100    let mut local_var_req_builder =
12101        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
12102
12103    if let Some(ref local_var_str) = format {
12104        local_var_req_builder =
12105            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12106    }
12107    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12108        local_var_req_builder =
12109            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12110    }
12111    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12112        let local_var_key = local_var_apikey.key.clone();
12113        let local_var_value = match local_var_apikey.prefix {
12114            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12115            None => local_var_key,
12116        };
12117        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12118    };
12119
12120    let local_var_req = local_var_req_builder.build()?;
12121    let local_var_resp = local_var_client.execute(local_var_req).await?;
12122
12123    let local_var_status = local_var_resp.status();
12124    let local_var_content = local_var_resp.text().await?;
12125
12126    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12127        Ok(())
12128    } else {
12129        let local_var_entity: Option<IpamRouteTargetsDestroyError> =
12130            serde_json::from_str(&local_var_content).ok();
12131        let local_var_error = ResponseContent {
12132            status: local_var_status,
12133            content: local_var_content,
12134            entity: local_var_entity,
12135        };
12136        Err(Error::ResponseError(local_var_error))
12137    }
12138}
12139
12140/// Retrieve a list of route target objects.
12141pub async fn ipam_route_targets_list(
12142    configuration: &configuration::Configuration,
12143    contacts: Option<Vec<String>>,
12144    contacts__isnull: Option<bool>,
12145    contacts__n: Option<Vec<String>>,
12146    created: Option<Vec<String>>,
12147    created__gt: Option<Vec<String>>,
12148    created__gte: Option<Vec<String>>,
12149    created__isnull: Option<bool>,
12150    created__lt: Option<Vec<String>>,
12151    created__lte: Option<Vec<String>>,
12152    created__n: Option<Vec<String>>,
12153    dynamic_groups: Option<Vec<String>>,
12154    dynamic_groups__n: Option<Vec<String>>,
12155    exporting_vrfs: Option<Vec<String>>,
12156    exporting_vrfs__isnull: Option<bool>,
12157    exporting_vrfs__n: Option<Vec<String>>,
12158    format: Option<&str>,
12159    id: Option<Vec<uuid::Uuid>>,
12160    id__n: Option<Vec<uuid::Uuid>>,
12161    importing_vrfs: Option<Vec<String>>,
12162    importing_vrfs__isnull: Option<bool>,
12163    importing_vrfs__n: Option<Vec<String>>,
12164    last_updated: Option<Vec<String>>,
12165    last_updated__gt: Option<Vec<String>>,
12166    last_updated__gte: Option<Vec<String>>,
12167    last_updated__isnull: Option<bool>,
12168    last_updated__lt: Option<Vec<String>>,
12169    last_updated__lte: Option<Vec<String>>,
12170    last_updated__n: Option<Vec<String>>,
12171    limit: Option<i32>,
12172    name: Option<Vec<String>>,
12173    name__ic: Option<Vec<String>>,
12174    name__ie: Option<Vec<String>>,
12175    name__iew: Option<Vec<String>>,
12176    name__ire: Option<Vec<String>>,
12177    name__isw: Option<Vec<String>>,
12178    name__n: Option<Vec<String>>,
12179    name__nic: Option<Vec<String>>,
12180    name__nie: Option<Vec<String>>,
12181    name__niew: Option<Vec<String>>,
12182    name__nire: Option<Vec<String>>,
12183    name__nisw: Option<Vec<String>>,
12184    name__nre: Option<Vec<String>>,
12185    name__re: Option<Vec<String>>,
12186    offset: Option<i32>,
12187    q: Option<&str>,
12188    sort: Option<&str>,
12189    tags: Option<Vec<String>>,
12190    tags__isnull: Option<bool>,
12191    tags__n: Option<Vec<String>>,
12192    teams: Option<Vec<String>>,
12193    teams__isnull: Option<bool>,
12194    teams__n: Option<Vec<String>>,
12195    tenant: Option<Vec<String>>,
12196    tenant__isnull: Option<bool>,
12197    tenant__n: Option<Vec<String>>,
12198    tenant_group: Option<Vec<String>>,
12199    tenant_group__isnull: Option<bool>,
12200    tenant_group__n: Option<Vec<String>>,
12201    tenant_id: Option<Vec<uuid::Uuid>>,
12202    tenant_id__isnull: Option<bool>,
12203    tenant_id__n: Option<Vec<uuid::Uuid>>,
12204    depth: Option<i32>,
12205    exclude_m2m: Option<bool>,
12206) -> Result<crate::models::PaginatedRouteTargetList, Error<IpamRouteTargetsListError>> {
12207    let local_var_configuration = configuration;
12208
12209    let local_var_client = &local_var_configuration.client;
12210
12211    let local_var_uri_str = format!("{}/ipam/route-targets/", local_var_configuration.base_path);
12212    let mut local_var_req_builder =
12213        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12214
12215    if let Some(ref local_var_str) = contacts {
12216        local_var_req_builder = match "multi" {
12217            "multi" => local_var_req_builder.query(
12218                &local_var_str
12219                    .into_iter()
12220                    .map(|p| ("contacts".to_owned(), p.to_string()))
12221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12222            ),
12223            _ => local_var_req_builder.query(&[(
12224                "contacts",
12225                &local_var_str
12226                    .into_iter()
12227                    .map(|p| p.to_string())
12228                    .collect::<Vec<String>>()
12229                    .join(",")
12230                    .to_string(),
12231            )]),
12232        };
12233    }
12234    if let Some(ref local_var_str) = contacts__isnull {
12235        local_var_req_builder =
12236            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
12237    }
12238    if let Some(ref local_var_str) = contacts__n {
12239        local_var_req_builder = match "multi" {
12240            "multi" => local_var_req_builder.query(
12241                &local_var_str
12242                    .into_iter()
12243                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
12244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12245            ),
12246            _ => local_var_req_builder.query(&[(
12247                "contacts__n",
12248                &local_var_str
12249                    .into_iter()
12250                    .map(|p| p.to_string())
12251                    .collect::<Vec<String>>()
12252                    .join(",")
12253                    .to_string(),
12254            )]),
12255        };
12256    }
12257    if let Some(ref local_var_str) = created {
12258        local_var_req_builder = match "multi" {
12259            "multi" => local_var_req_builder.query(
12260                &local_var_str
12261                    .into_iter()
12262                    .map(|p| ("created".to_owned(), p.to_string()))
12263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12264            ),
12265            _ => local_var_req_builder.query(&[(
12266                "created",
12267                &local_var_str
12268                    .into_iter()
12269                    .map(|p| p.to_string())
12270                    .collect::<Vec<String>>()
12271                    .join(",")
12272                    .to_string(),
12273            )]),
12274        };
12275    }
12276    if let Some(ref local_var_str) = created__gt {
12277        local_var_req_builder = match "multi" {
12278            "multi" => local_var_req_builder.query(
12279                &local_var_str
12280                    .into_iter()
12281                    .map(|p| ("created__gt".to_owned(), p.to_string()))
12282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12283            ),
12284            _ => local_var_req_builder.query(&[(
12285                "created__gt",
12286                &local_var_str
12287                    .into_iter()
12288                    .map(|p| p.to_string())
12289                    .collect::<Vec<String>>()
12290                    .join(",")
12291                    .to_string(),
12292            )]),
12293        };
12294    }
12295    if let Some(ref local_var_str) = created__gte {
12296        local_var_req_builder = match "multi" {
12297            "multi" => local_var_req_builder.query(
12298                &local_var_str
12299                    .into_iter()
12300                    .map(|p| ("created__gte".to_owned(), p.to_string()))
12301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12302            ),
12303            _ => local_var_req_builder.query(&[(
12304                "created__gte",
12305                &local_var_str
12306                    .into_iter()
12307                    .map(|p| p.to_string())
12308                    .collect::<Vec<String>>()
12309                    .join(",")
12310                    .to_string(),
12311            )]),
12312        };
12313    }
12314    if let Some(ref local_var_str) = created__isnull {
12315        local_var_req_builder =
12316            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
12317    }
12318    if let Some(ref local_var_str) = created__lt {
12319        local_var_req_builder = match "multi" {
12320            "multi" => local_var_req_builder.query(
12321                &local_var_str
12322                    .into_iter()
12323                    .map(|p| ("created__lt".to_owned(), p.to_string()))
12324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12325            ),
12326            _ => local_var_req_builder.query(&[(
12327                "created__lt",
12328                &local_var_str
12329                    .into_iter()
12330                    .map(|p| p.to_string())
12331                    .collect::<Vec<String>>()
12332                    .join(",")
12333                    .to_string(),
12334            )]),
12335        };
12336    }
12337    if let Some(ref local_var_str) = created__lte {
12338        local_var_req_builder = match "multi" {
12339            "multi" => local_var_req_builder.query(
12340                &local_var_str
12341                    .into_iter()
12342                    .map(|p| ("created__lte".to_owned(), p.to_string()))
12343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12344            ),
12345            _ => local_var_req_builder.query(&[(
12346                "created__lte",
12347                &local_var_str
12348                    .into_iter()
12349                    .map(|p| p.to_string())
12350                    .collect::<Vec<String>>()
12351                    .join(",")
12352                    .to_string(),
12353            )]),
12354        };
12355    }
12356    if let Some(ref local_var_str) = created__n {
12357        local_var_req_builder = match "multi" {
12358            "multi" => local_var_req_builder.query(
12359                &local_var_str
12360                    .into_iter()
12361                    .map(|p| ("created__n".to_owned(), p.to_string()))
12362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12363            ),
12364            _ => local_var_req_builder.query(&[(
12365                "created__n",
12366                &local_var_str
12367                    .into_iter()
12368                    .map(|p| p.to_string())
12369                    .collect::<Vec<String>>()
12370                    .join(",")
12371                    .to_string(),
12372            )]),
12373        };
12374    }
12375    if let Some(ref local_var_str) = dynamic_groups {
12376        local_var_req_builder = match "multi" {
12377            "multi" => local_var_req_builder.query(
12378                &local_var_str
12379                    .into_iter()
12380                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
12381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12382            ),
12383            _ => local_var_req_builder.query(&[(
12384                "dynamic_groups",
12385                &local_var_str
12386                    .into_iter()
12387                    .map(|p| p.to_string())
12388                    .collect::<Vec<String>>()
12389                    .join(",")
12390                    .to_string(),
12391            )]),
12392        };
12393    }
12394    if let Some(ref local_var_str) = dynamic_groups__n {
12395        local_var_req_builder = match "multi" {
12396            "multi" => local_var_req_builder.query(
12397                &local_var_str
12398                    .into_iter()
12399                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
12400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12401            ),
12402            _ => local_var_req_builder.query(&[(
12403                "dynamic_groups__n",
12404                &local_var_str
12405                    .into_iter()
12406                    .map(|p| p.to_string())
12407                    .collect::<Vec<String>>()
12408                    .join(",")
12409                    .to_string(),
12410            )]),
12411        };
12412    }
12413    if let Some(ref local_var_str) = exporting_vrfs {
12414        local_var_req_builder = match "multi" {
12415            "multi" => local_var_req_builder.query(
12416                &local_var_str
12417                    .into_iter()
12418                    .map(|p| ("exporting_vrfs".to_owned(), p.to_string()))
12419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12420            ),
12421            _ => local_var_req_builder.query(&[(
12422                "exporting_vrfs",
12423                &local_var_str
12424                    .into_iter()
12425                    .map(|p| p.to_string())
12426                    .collect::<Vec<String>>()
12427                    .join(",")
12428                    .to_string(),
12429            )]),
12430        };
12431    }
12432    if let Some(ref local_var_str) = exporting_vrfs__isnull {
12433        local_var_req_builder =
12434            local_var_req_builder.query(&[("exporting_vrfs__isnull", &local_var_str.to_string())]);
12435    }
12436    if let Some(ref local_var_str) = exporting_vrfs__n {
12437        local_var_req_builder = match "multi" {
12438            "multi" => local_var_req_builder.query(
12439                &local_var_str
12440                    .into_iter()
12441                    .map(|p| ("exporting_vrfs__n".to_owned(), p.to_string()))
12442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12443            ),
12444            _ => local_var_req_builder.query(&[(
12445                "exporting_vrfs__n",
12446                &local_var_str
12447                    .into_iter()
12448                    .map(|p| p.to_string())
12449                    .collect::<Vec<String>>()
12450                    .join(",")
12451                    .to_string(),
12452            )]),
12453        };
12454    }
12455    if let Some(ref local_var_str) = format {
12456        local_var_req_builder =
12457            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12458    }
12459    if let Some(ref local_var_str) = id {
12460        local_var_req_builder = match "multi" {
12461            "multi" => local_var_req_builder.query(
12462                &local_var_str
12463                    .into_iter()
12464                    .map(|p| ("id".to_owned(), p.to_string()))
12465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12466            ),
12467            _ => local_var_req_builder.query(&[(
12468                "id",
12469                &local_var_str
12470                    .into_iter()
12471                    .map(|p| p.to_string())
12472                    .collect::<Vec<String>>()
12473                    .join(",")
12474                    .to_string(),
12475            )]),
12476        };
12477    }
12478    if let Some(ref local_var_str) = id__n {
12479        local_var_req_builder = match "multi" {
12480            "multi" => local_var_req_builder.query(
12481                &local_var_str
12482                    .into_iter()
12483                    .map(|p| ("id__n".to_owned(), p.to_string()))
12484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12485            ),
12486            _ => local_var_req_builder.query(&[(
12487                "id__n",
12488                &local_var_str
12489                    .into_iter()
12490                    .map(|p| p.to_string())
12491                    .collect::<Vec<String>>()
12492                    .join(",")
12493                    .to_string(),
12494            )]),
12495        };
12496    }
12497    if let Some(ref local_var_str) = importing_vrfs {
12498        local_var_req_builder = match "multi" {
12499            "multi" => local_var_req_builder.query(
12500                &local_var_str
12501                    .into_iter()
12502                    .map(|p| ("importing_vrfs".to_owned(), p.to_string()))
12503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12504            ),
12505            _ => local_var_req_builder.query(&[(
12506                "importing_vrfs",
12507                &local_var_str
12508                    .into_iter()
12509                    .map(|p| p.to_string())
12510                    .collect::<Vec<String>>()
12511                    .join(",")
12512                    .to_string(),
12513            )]),
12514        };
12515    }
12516    if let Some(ref local_var_str) = importing_vrfs__isnull {
12517        local_var_req_builder =
12518            local_var_req_builder.query(&[("importing_vrfs__isnull", &local_var_str.to_string())]);
12519    }
12520    if let Some(ref local_var_str) = importing_vrfs__n {
12521        local_var_req_builder = match "multi" {
12522            "multi" => local_var_req_builder.query(
12523                &local_var_str
12524                    .into_iter()
12525                    .map(|p| ("importing_vrfs__n".to_owned(), p.to_string()))
12526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12527            ),
12528            _ => local_var_req_builder.query(&[(
12529                "importing_vrfs__n",
12530                &local_var_str
12531                    .into_iter()
12532                    .map(|p| p.to_string())
12533                    .collect::<Vec<String>>()
12534                    .join(",")
12535                    .to_string(),
12536            )]),
12537        };
12538    }
12539    if let Some(ref local_var_str) = last_updated {
12540        local_var_req_builder = match "multi" {
12541            "multi" => local_var_req_builder.query(
12542                &local_var_str
12543                    .into_iter()
12544                    .map(|p| ("last_updated".to_owned(), p.to_string()))
12545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12546            ),
12547            _ => local_var_req_builder.query(&[(
12548                "last_updated",
12549                &local_var_str
12550                    .into_iter()
12551                    .map(|p| p.to_string())
12552                    .collect::<Vec<String>>()
12553                    .join(",")
12554                    .to_string(),
12555            )]),
12556        };
12557    }
12558    if let Some(ref local_var_str) = last_updated__gt {
12559        local_var_req_builder = match "multi" {
12560            "multi" => local_var_req_builder.query(
12561                &local_var_str
12562                    .into_iter()
12563                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
12564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12565            ),
12566            _ => local_var_req_builder.query(&[(
12567                "last_updated__gt",
12568                &local_var_str
12569                    .into_iter()
12570                    .map(|p| p.to_string())
12571                    .collect::<Vec<String>>()
12572                    .join(",")
12573                    .to_string(),
12574            )]),
12575        };
12576    }
12577    if let Some(ref local_var_str) = last_updated__gte {
12578        local_var_req_builder = match "multi" {
12579            "multi" => local_var_req_builder.query(
12580                &local_var_str
12581                    .into_iter()
12582                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
12583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12584            ),
12585            _ => local_var_req_builder.query(&[(
12586                "last_updated__gte",
12587                &local_var_str
12588                    .into_iter()
12589                    .map(|p| p.to_string())
12590                    .collect::<Vec<String>>()
12591                    .join(",")
12592                    .to_string(),
12593            )]),
12594        };
12595    }
12596    if let Some(ref local_var_str) = last_updated__isnull {
12597        local_var_req_builder =
12598            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
12599    }
12600    if let Some(ref local_var_str) = last_updated__lt {
12601        local_var_req_builder = match "multi" {
12602            "multi" => local_var_req_builder.query(
12603                &local_var_str
12604                    .into_iter()
12605                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
12606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12607            ),
12608            _ => local_var_req_builder.query(&[(
12609                "last_updated__lt",
12610                &local_var_str
12611                    .into_iter()
12612                    .map(|p| p.to_string())
12613                    .collect::<Vec<String>>()
12614                    .join(",")
12615                    .to_string(),
12616            )]),
12617        };
12618    }
12619    if let Some(ref local_var_str) = last_updated__lte {
12620        local_var_req_builder = match "multi" {
12621            "multi" => local_var_req_builder.query(
12622                &local_var_str
12623                    .into_iter()
12624                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
12625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12626            ),
12627            _ => local_var_req_builder.query(&[(
12628                "last_updated__lte",
12629                &local_var_str
12630                    .into_iter()
12631                    .map(|p| p.to_string())
12632                    .collect::<Vec<String>>()
12633                    .join(",")
12634                    .to_string(),
12635            )]),
12636        };
12637    }
12638    if let Some(ref local_var_str) = last_updated__n {
12639        local_var_req_builder = match "multi" {
12640            "multi" => local_var_req_builder.query(
12641                &local_var_str
12642                    .into_iter()
12643                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
12644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12645            ),
12646            _ => local_var_req_builder.query(&[(
12647                "last_updated__n",
12648                &local_var_str
12649                    .into_iter()
12650                    .map(|p| p.to_string())
12651                    .collect::<Vec<String>>()
12652                    .join(",")
12653                    .to_string(),
12654            )]),
12655        };
12656    }
12657    if let Some(ref local_var_str) = limit {
12658        local_var_req_builder =
12659            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12660    }
12661    if let Some(ref local_var_str) = name {
12662        local_var_req_builder = match "multi" {
12663            "multi" => local_var_req_builder.query(
12664                &local_var_str
12665                    .into_iter()
12666                    .map(|p| ("name".to_owned(), p.to_string()))
12667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12668            ),
12669            _ => local_var_req_builder.query(&[(
12670                "name",
12671                &local_var_str
12672                    .into_iter()
12673                    .map(|p| p.to_string())
12674                    .collect::<Vec<String>>()
12675                    .join(",")
12676                    .to_string(),
12677            )]),
12678        };
12679    }
12680    if let Some(ref local_var_str) = name__ic {
12681        local_var_req_builder = match "multi" {
12682            "multi" => local_var_req_builder.query(
12683                &local_var_str
12684                    .into_iter()
12685                    .map(|p| ("name__ic".to_owned(), p.to_string()))
12686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12687            ),
12688            _ => local_var_req_builder.query(&[(
12689                "name__ic",
12690                &local_var_str
12691                    .into_iter()
12692                    .map(|p| p.to_string())
12693                    .collect::<Vec<String>>()
12694                    .join(",")
12695                    .to_string(),
12696            )]),
12697        };
12698    }
12699    if let Some(ref local_var_str) = name__ie {
12700        local_var_req_builder = match "multi" {
12701            "multi" => local_var_req_builder.query(
12702                &local_var_str
12703                    .into_iter()
12704                    .map(|p| ("name__ie".to_owned(), p.to_string()))
12705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12706            ),
12707            _ => local_var_req_builder.query(&[(
12708                "name__ie",
12709                &local_var_str
12710                    .into_iter()
12711                    .map(|p| p.to_string())
12712                    .collect::<Vec<String>>()
12713                    .join(",")
12714                    .to_string(),
12715            )]),
12716        };
12717    }
12718    if let Some(ref local_var_str) = name__iew {
12719        local_var_req_builder = match "multi" {
12720            "multi" => local_var_req_builder.query(
12721                &local_var_str
12722                    .into_iter()
12723                    .map(|p| ("name__iew".to_owned(), p.to_string()))
12724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12725            ),
12726            _ => local_var_req_builder.query(&[(
12727                "name__iew",
12728                &local_var_str
12729                    .into_iter()
12730                    .map(|p| p.to_string())
12731                    .collect::<Vec<String>>()
12732                    .join(",")
12733                    .to_string(),
12734            )]),
12735        };
12736    }
12737    if let Some(ref local_var_str) = name__ire {
12738        local_var_req_builder = match "multi" {
12739            "multi" => local_var_req_builder.query(
12740                &local_var_str
12741                    .into_iter()
12742                    .map(|p| ("name__ire".to_owned(), p.to_string()))
12743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12744            ),
12745            _ => local_var_req_builder.query(&[(
12746                "name__ire",
12747                &local_var_str
12748                    .into_iter()
12749                    .map(|p| p.to_string())
12750                    .collect::<Vec<String>>()
12751                    .join(",")
12752                    .to_string(),
12753            )]),
12754        };
12755    }
12756    if let Some(ref local_var_str) = name__isw {
12757        local_var_req_builder = match "multi" {
12758            "multi" => local_var_req_builder.query(
12759                &local_var_str
12760                    .into_iter()
12761                    .map(|p| ("name__isw".to_owned(), p.to_string()))
12762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12763            ),
12764            _ => local_var_req_builder.query(&[(
12765                "name__isw",
12766                &local_var_str
12767                    .into_iter()
12768                    .map(|p| p.to_string())
12769                    .collect::<Vec<String>>()
12770                    .join(",")
12771                    .to_string(),
12772            )]),
12773        };
12774    }
12775    if let Some(ref local_var_str) = name__n {
12776        local_var_req_builder = match "multi" {
12777            "multi" => local_var_req_builder.query(
12778                &local_var_str
12779                    .into_iter()
12780                    .map(|p| ("name__n".to_owned(), p.to_string()))
12781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12782            ),
12783            _ => local_var_req_builder.query(&[(
12784                "name__n",
12785                &local_var_str
12786                    .into_iter()
12787                    .map(|p| p.to_string())
12788                    .collect::<Vec<String>>()
12789                    .join(",")
12790                    .to_string(),
12791            )]),
12792        };
12793    }
12794    if let Some(ref local_var_str) = name__nic {
12795        local_var_req_builder = match "multi" {
12796            "multi" => local_var_req_builder.query(
12797                &local_var_str
12798                    .into_iter()
12799                    .map(|p| ("name__nic".to_owned(), p.to_string()))
12800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12801            ),
12802            _ => local_var_req_builder.query(&[(
12803                "name__nic",
12804                &local_var_str
12805                    .into_iter()
12806                    .map(|p| p.to_string())
12807                    .collect::<Vec<String>>()
12808                    .join(",")
12809                    .to_string(),
12810            )]),
12811        };
12812    }
12813    if let Some(ref local_var_str) = name__nie {
12814        local_var_req_builder = match "multi" {
12815            "multi" => local_var_req_builder.query(
12816                &local_var_str
12817                    .into_iter()
12818                    .map(|p| ("name__nie".to_owned(), p.to_string()))
12819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12820            ),
12821            _ => local_var_req_builder.query(&[(
12822                "name__nie",
12823                &local_var_str
12824                    .into_iter()
12825                    .map(|p| p.to_string())
12826                    .collect::<Vec<String>>()
12827                    .join(",")
12828                    .to_string(),
12829            )]),
12830        };
12831    }
12832    if let Some(ref local_var_str) = name__niew {
12833        local_var_req_builder = match "multi" {
12834            "multi" => local_var_req_builder.query(
12835                &local_var_str
12836                    .into_iter()
12837                    .map(|p| ("name__niew".to_owned(), p.to_string()))
12838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12839            ),
12840            _ => local_var_req_builder.query(&[(
12841                "name__niew",
12842                &local_var_str
12843                    .into_iter()
12844                    .map(|p| p.to_string())
12845                    .collect::<Vec<String>>()
12846                    .join(",")
12847                    .to_string(),
12848            )]),
12849        };
12850    }
12851    if let Some(ref local_var_str) = name__nire {
12852        local_var_req_builder = match "multi" {
12853            "multi" => local_var_req_builder.query(
12854                &local_var_str
12855                    .into_iter()
12856                    .map(|p| ("name__nire".to_owned(), p.to_string()))
12857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12858            ),
12859            _ => local_var_req_builder.query(&[(
12860                "name__nire",
12861                &local_var_str
12862                    .into_iter()
12863                    .map(|p| p.to_string())
12864                    .collect::<Vec<String>>()
12865                    .join(",")
12866                    .to_string(),
12867            )]),
12868        };
12869    }
12870    if let Some(ref local_var_str) = name__nisw {
12871        local_var_req_builder = match "multi" {
12872            "multi" => local_var_req_builder.query(
12873                &local_var_str
12874                    .into_iter()
12875                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
12876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12877            ),
12878            _ => local_var_req_builder.query(&[(
12879                "name__nisw",
12880                &local_var_str
12881                    .into_iter()
12882                    .map(|p| p.to_string())
12883                    .collect::<Vec<String>>()
12884                    .join(",")
12885                    .to_string(),
12886            )]),
12887        };
12888    }
12889    if let Some(ref local_var_str) = name__nre {
12890        local_var_req_builder = match "multi" {
12891            "multi" => local_var_req_builder.query(
12892                &local_var_str
12893                    .into_iter()
12894                    .map(|p| ("name__nre".to_owned(), p.to_string()))
12895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12896            ),
12897            _ => local_var_req_builder.query(&[(
12898                "name__nre",
12899                &local_var_str
12900                    .into_iter()
12901                    .map(|p| p.to_string())
12902                    .collect::<Vec<String>>()
12903                    .join(",")
12904                    .to_string(),
12905            )]),
12906        };
12907    }
12908    if let Some(ref local_var_str) = name__re {
12909        local_var_req_builder = match "multi" {
12910            "multi" => local_var_req_builder.query(
12911                &local_var_str
12912                    .into_iter()
12913                    .map(|p| ("name__re".to_owned(), p.to_string()))
12914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12915            ),
12916            _ => local_var_req_builder.query(&[(
12917                "name__re",
12918                &local_var_str
12919                    .into_iter()
12920                    .map(|p| p.to_string())
12921                    .collect::<Vec<String>>()
12922                    .join(",")
12923                    .to_string(),
12924            )]),
12925        };
12926    }
12927    if let Some(ref local_var_str) = offset {
12928        local_var_req_builder =
12929            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12930    }
12931    if let Some(ref local_var_str) = q {
12932        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12933    }
12934    if let Some(ref local_var_str) = sort {
12935        local_var_req_builder =
12936            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
12937    }
12938    if let Some(ref local_var_str) = tags {
12939        local_var_req_builder = match "multi" {
12940            "multi" => local_var_req_builder.query(
12941                &local_var_str
12942                    .into_iter()
12943                    .map(|p| ("tags".to_owned(), p.to_string()))
12944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12945            ),
12946            _ => local_var_req_builder.query(&[(
12947                "tags",
12948                &local_var_str
12949                    .into_iter()
12950                    .map(|p| p.to_string())
12951                    .collect::<Vec<String>>()
12952                    .join(",")
12953                    .to_string(),
12954            )]),
12955        };
12956    }
12957    if let Some(ref local_var_str) = tags__isnull {
12958        local_var_req_builder =
12959            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
12960    }
12961    if let Some(ref local_var_str) = tags__n {
12962        local_var_req_builder = match "multi" {
12963            "multi" => local_var_req_builder.query(
12964                &local_var_str
12965                    .into_iter()
12966                    .map(|p| ("tags__n".to_owned(), p.to_string()))
12967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12968            ),
12969            _ => local_var_req_builder.query(&[(
12970                "tags__n",
12971                &local_var_str
12972                    .into_iter()
12973                    .map(|p| p.to_string())
12974                    .collect::<Vec<String>>()
12975                    .join(",")
12976                    .to_string(),
12977            )]),
12978        };
12979    }
12980    if let Some(ref local_var_str) = teams {
12981        local_var_req_builder = match "multi" {
12982            "multi" => local_var_req_builder.query(
12983                &local_var_str
12984                    .into_iter()
12985                    .map(|p| ("teams".to_owned(), p.to_string()))
12986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12987            ),
12988            _ => local_var_req_builder.query(&[(
12989                "teams",
12990                &local_var_str
12991                    .into_iter()
12992                    .map(|p| p.to_string())
12993                    .collect::<Vec<String>>()
12994                    .join(",")
12995                    .to_string(),
12996            )]),
12997        };
12998    }
12999    if let Some(ref local_var_str) = teams__isnull {
13000        local_var_req_builder =
13001            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
13002    }
13003    if let Some(ref local_var_str) = teams__n {
13004        local_var_req_builder = match "multi" {
13005            "multi" => local_var_req_builder.query(
13006                &local_var_str
13007                    .into_iter()
13008                    .map(|p| ("teams__n".to_owned(), p.to_string()))
13009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13010            ),
13011            _ => local_var_req_builder.query(&[(
13012                "teams__n",
13013                &local_var_str
13014                    .into_iter()
13015                    .map(|p| p.to_string())
13016                    .collect::<Vec<String>>()
13017                    .join(",")
13018                    .to_string(),
13019            )]),
13020        };
13021    }
13022    if let Some(ref local_var_str) = tenant {
13023        local_var_req_builder = match "multi" {
13024            "multi" => local_var_req_builder.query(
13025                &local_var_str
13026                    .into_iter()
13027                    .map(|p| ("tenant".to_owned(), p.to_string()))
13028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13029            ),
13030            _ => local_var_req_builder.query(&[(
13031                "tenant",
13032                &local_var_str
13033                    .into_iter()
13034                    .map(|p| p.to_string())
13035                    .collect::<Vec<String>>()
13036                    .join(",")
13037                    .to_string(),
13038            )]),
13039        };
13040    }
13041    if let Some(ref local_var_str) = tenant__isnull {
13042        local_var_req_builder =
13043            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
13044    }
13045    if let Some(ref local_var_str) = tenant__n {
13046        local_var_req_builder = match "multi" {
13047            "multi" => local_var_req_builder.query(
13048                &local_var_str
13049                    .into_iter()
13050                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
13051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13052            ),
13053            _ => local_var_req_builder.query(&[(
13054                "tenant__n",
13055                &local_var_str
13056                    .into_iter()
13057                    .map(|p| p.to_string())
13058                    .collect::<Vec<String>>()
13059                    .join(",")
13060                    .to_string(),
13061            )]),
13062        };
13063    }
13064    if let Some(ref local_var_str) = tenant_group {
13065        local_var_req_builder = match "multi" {
13066            "multi" => local_var_req_builder.query(
13067                &local_var_str
13068                    .into_iter()
13069                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
13070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13071            ),
13072            _ => local_var_req_builder.query(&[(
13073                "tenant_group",
13074                &local_var_str
13075                    .into_iter()
13076                    .map(|p| p.to_string())
13077                    .collect::<Vec<String>>()
13078                    .join(",")
13079                    .to_string(),
13080            )]),
13081        };
13082    }
13083    if let Some(ref local_var_str) = tenant_group__isnull {
13084        local_var_req_builder =
13085            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
13086    }
13087    if let Some(ref local_var_str) = tenant_group__n {
13088        local_var_req_builder = match "multi" {
13089            "multi" => local_var_req_builder.query(
13090                &local_var_str
13091                    .into_iter()
13092                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
13093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13094            ),
13095            _ => local_var_req_builder.query(&[(
13096                "tenant_group__n",
13097                &local_var_str
13098                    .into_iter()
13099                    .map(|p| p.to_string())
13100                    .collect::<Vec<String>>()
13101                    .join(",")
13102                    .to_string(),
13103            )]),
13104        };
13105    }
13106    if let Some(ref local_var_str) = tenant_id {
13107        local_var_req_builder = match "multi" {
13108            "multi" => local_var_req_builder.query(
13109                &local_var_str
13110                    .into_iter()
13111                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
13112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13113            ),
13114            _ => local_var_req_builder.query(&[(
13115                "tenant_id",
13116                &local_var_str
13117                    .into_iter()
13118                    .map(|p| p.to_string())
13119                    .collect::<Vec<String>>()
13120                    .join(",")
13121                    .to_string(),
13122            )]),
13123        };
13124    }
13125    if let Some(ref local_var_str) = tenant_id__isnull {
13126        local_var_req_builder =
13127            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
13128    }
13129    if let Some(ref local_var_str) = tenant_id__n {
13130        local_var_req_builder = match "multi" {
13131            "multi" => local_var_req_builder.query(
13132                &local_var_str
13133                    .into_iter()
13134                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
13135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13136            ),
13137            _ => local_var_req_builder.query(&[(
13138                "tenant_id__n",
13139                &local_var_str
13140                    .into_iter()
13141                    .map(|p| p.to_string())
13142                    .collect::<Vec<String>>()
13143                    .join(",")
13144                    .to_string(),
13145            )]),
13146        };
13147    }
13148    if let Some(ref local_var_str) = depth {
13149        local_var_req_builder =
13150            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
13151    }
13152    if let Some(ref local_var_str) = exclude_m2m {
13153        local_var_req_builder =
13154            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
13155    }
13156    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13157        local_var_req_builder =
13158            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13159    }
13160    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13161        let local_var_key = local_var_apikey.key.clone();
13162        let local_var_value = match local_var_apikey.prefix {
13163            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13164            None => local_var_key,
13165        };
13166        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13167    };
13168
13169    let local_var_req = local_var_req_builder.build()?;
13170    let local_var_resp = local_var_client.execute(local_var_req).await?;
13171
13172    let local_var_status = local_var_resp.status();
13173    let local_var_content = local_var_resp.text().await?;
13174
13175    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13176        serde_json::from_str(&local_var_content).map_err(Error::from)
13177    } else {
13178        let local_var_entity: Option<IpamRouteTargetsListError> =
13179            serde_json::from_str(&local_var_content).ok();
13180        let local_var_error = ResponseContent {
13181            status: local_var_status,
13182            content: local_var_content,
13183            entity: local_var_entity,
13184        };
13185        Err(Error::ResponseError(local_var_error))
13186    }
13187}
13188
13189/// API methods for returning or creating notes on an object.
13190pub async fn ipam_route_targets_notes_create(
13191    configuration: &configuration::Configuration,
13192    id: &str,
13193    note_input_request: crate::models::NoteInputRequest,
13194    format: Option<&str>,
13195) -> Result<crate::models::Note, Error<IpamRouteTargetsNotesCreateError>> {
13196    let local_var_configuration = configuration;
13197
13198    let local_var_client = &local_var_configuration.client;
13199
13200    let local_var_uri_str = format!(
13201        "{}/ipam/route-targets/{id}/notes/",
13202        local_var_configuration.base_path,
13203        id = crate::apis::urlencode(id)
13204    );
13205    let mut local_var_req_builder =
13206        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13207
13208    if let Some(ref local_var_str) = format {
13209        local_var_req_builder =
13210            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13211    }
13212    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13213        local_var_req_builder =
13214            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13215    }
13216    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13217        let local_var_key = local_var_apikey.key.clone();
13218        let local_var_value = match local_var_apikey.prefix {
13219            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13220            None => local_var_key,
13221        };
13222        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13223    };
13224    local_var_req_builder = local_var_req_builder.json(&note_input_request);
13225
13226    let local_var_req = local_var_req_builder.build()?;
13227    let local_var_resp = local_var_client.execute(local_var_req).await?;
13228
13229    let local_var_status = local_var_resp.status();
13230    let local_var_content = local_var_resp.text().await?;
13231
13232    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13233        serde_json::from_str(&local_var_content).map_err(Error::from)
13234    } else {
13235        let local_var_entity: Option<IpamRouteTargetsNotesCreateError> =
13236            serde_json::from_str(&local_var_content).ok();
13237        let local_var_error = ResponseContent {
13238            status: local_var_status,
13239            content: local_var_content,
13240            entity: local_var_entity,
13241        };
13242        Err(Error::ResponseError(local_var_error))
13243    }
13244}
13245
13246/// API methods for returning or creating notes on an object.
13247pub async fn ipam_route_targets_notes_list(
13248    configuration: &configuration::Configuration,
13249    id: &str,
13250    format: Option<&str>,
13251    limit: Option<i32>,
13252    offset: Option<i32>,
13253    depth: Option<i32>,
13254    exclude_m2m: Option<bool>,
13255) -> Result<crate::models::PaginatedNoteList, Error<IpamRouteTargetsNotesListError>> {
13256    let local_var_configuration = configuration;
13257
13258    let local_var_client = &local_var_configuration.client;
13259
13260    let local_var_uri_str = format!(
13261        "{}/ipam/route-targets/{id}/notes/",
13262        local_var_configuration.base_path,
13263        id = crate::apis::urlencode(id)
13264    );
13265    let mut local_var_req_builder =
13266        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13267
13268    if let Some(ref local_var_str) = format {
13269        local_var_req_builder =
13270            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13271    }
13272    if let Some(ref local_var_str) = limit {
13273        local_var_req_builder =
13274            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
13275    }
13276    if let Some(ref local_var_str) = offset {
13277        local_var_req_builder =
13278            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
13279    }
13280    if let Some(ref local_var_str) = depth {
13281        local_var_req_builder =
13282            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
13283    }
13284    if let Some(ref local_var_str) = exclude_m2m {
13285        local_var_req_builder =
13286            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
13287    }
13288    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13289        local_var_req_builder =
13290            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13291    }
13292    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13293        let local_var_key = local_var_apikey.key.clone();
13294        let local_var_value = match local_var_apikey.prefix {
13295            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13296            None => local_var_key,
13297        };
13298        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13299    };
13300
13301    let local_var_req = local_var_req_builder.build()?;
13302    let local_var_resp = local_var_client.execute(local_var_req).await?;
13303
13304    let local_var_status = local_var_resp.status();
13305    let local_var_content = local_var_resp.text().await?;
13306
13307    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13308        serde_json::from_str(&local_var_content).map_err(Error::from)
13309    } else {
13310        let local_var_entity: Option<IpamRouteTargetsNotesListError> =
13311            serde_json::from_str(&local_var_content).ok();
13312        let local_var_error = ResponseContent {
13313            status: local_var_status,
13314            content: local_var_content,
13315            entity: local_var_entity,
13316        };
13317        Err(Error::ResponseError(local_var_error))
13318    }
13319}
13320
13321/// Partial update a route target object.
13322pub async fn ipam_route_targets_partial_update(
13323    configuration: &configuration::Configuration,
13324    id: &str,
13325    format: Option<&str>,
13326    patched_route_target_request: Option<crate::models::PatchedRouteTargetRequest>,
13327) -> Result<crate::models::RouteTarget, Error<IpamRouteTargetsPartialUpdateError>> {
13328    let local_var_configuration = configuration;
13329
13330    let local_var_client = &local_var_configuration.client;
13331
13332    let local_var_uri_str = format!(
13333        "{}/ipam/route-targets/{id}/",
13334        local_var_configuration.base_path,
13335        id = crate::apis::urlencode(id)
13336    );
13337    let mut local_var_req_builder =
13338        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13339
13340    if let Some(ref local_var_str) = format {
13341        local_var_req_builder =
13342            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13343    }
13344    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13345        local_var_req_builder =
13346            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13347    }
13348    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13349        let local_var_key = local_var_apikey.key.clone();
13350        let local_var_value = match local_var_apikey.prefix {
13351            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13352            None => local_var_key,
13353        };
13354        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13355    };
13356    local_var_req_builder = local_var_req_builder.json(&patched_route_target_request);
13357
13358    let local_var_req = local_var_req_builder.build()?;
13359    let local_var_resp = local_var_client.execute(local_var_req).await?;
13360
13361    let local_var_status = local_var_resp.status();
13362    let local_var_content = local_var_resp.text().await?;
13363
13364    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13365        serde_json::from_str(&local_var_content).map_err(Error::from)
13366    } else {
13367        let local_var_entity: Option<IpamRouteTargetsPartialUpdateError> =
13368            serde_json::from_str(&local_var_content).ok();
13369        let local_var_error = ResponseContent {
13370            status: local_var_status,
13371            content: local_var_content,
13372            entity: local_var_entity,
13373        };
13374        Err(Error::ResponseError(local_var_error))
13375    }
13376}
13377
13378/// Retrieve a route target object.
13379pub async fn ipam_route_targets_retrieve(
13380    configuration: &configuration::Configuration,
13381    id: &str,
13382    format: Option<&str>,
13383    depth: Option<i32>,
13384    exclude_m2m: Option<bool>,
13385) -> Result<crate::models::RouteTarget, Error<IpamRouteTargetsRetrieveError>> {
13386    let local_var_configuration = configuration;
13387
13388    let local_var_client = &local_var_configuration.client;
13389
13390    let local_var_uri_str = format!(
13391        "{}/ipam/route-targets/{id}/",
13392        local_var_configuration.base_path,
13393        id = crate::apis::urlencode(id)
13394    );
13395    let mut local_var_req_builder =
13396        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13397
13398    if let Some(ref local_var_str) = format {
13399        local_var_req_builder =
13400            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13401    }
13402    if let Some(ref local_var_str) = depth {
13403        local_var_req_builder =
13404            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
13405    }
13406    if let Some(ref local_var_str) = exclude_m2m {
13407        local_var_req_builder =
13408            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
13409    }
13410    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13411        local_var_req_builder =
13412            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13413    }
13414    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13415        let local_var_key = local_var_apikey.key.clone();
13416        let local_var_value = match local_var_apikey.prefix {
13417            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13418            None => local_var_key,
13419        };
13420        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13421    };
13422
13423    let local_var_req = local_var_req_builder.build()?;
13424    let local_var_resp = local_var_client.execute(local_var_req).await?;
13425
13426    let local_var_status = local_var_resp.status();
13427    let local_var_content = local_var_resp.text().await?;
13428
13429    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13430        serde_json::from_str(&local_var_content).map_err(Error::from)
13431    } else {
13432        let local_var_entity: Option<IpamRouteTargetsRetrieveError> =
13433            serde_json::from_str(&local_var_content).ok();
13434        let local_var_error = ResponseContent {
13435            status: local_var_status,
13436            content: local_var_content,
13437            entity: local_var_entity,
13438        };
13439        Err(Error::ResponseError(local_var_error))
13440    }
13441}
13442
13443/// Update a route target object.
13444pub async fn ipam_route_targets_update(
13445    configuration: &configuration::Configuration,
13446    id: &str,
13447    route_target_request: crate::models::RouteTargetRequest,
13448    format: Option<&str>,
13449) -> Result<crate::models::RouteTarget, Error<IpamRouteTargetsUpdateError>> {
13450    let local_var_configuration = configuration;
13451
13452    let local_var_client = &local_var_configuration.client;
13453
13454    let local_var_uri_str = format!(
13455        "{}/ipam/route-targets/{id}/",
13456        local_var_configuration.base_path,
13457        id = crate::apis::urlencode(id)
13458    );
13459    let mut local_var_req_builder =
13460        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13461
13462    if let Some(ref local_var_str) = format {
13463        local_var_req_builder =
13464            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13465    }
13466    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13467        local_var_req_builder =
13468            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13469    }
13470    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13471        let local_var_key = local_var_apikey.key.clone();
13472        let local_var_value = match local_var_apikey.prefix {
13473            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13474            None => local_var_key,
13475        };
13476        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13477    };
13478    local_var_req_builder = local_var_req_builder.json(&route_target_request);
13479
13480    let local_var_req = local_var_req_builder.build()?;
13481    let local_var_resp = local_var_client.execute(local_var_req).await?;
13482
13483    let local_var_status = local_var_resp.status();
13484    let local_var_content = local_var_resp.text().await?;
13485
13486    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13487        serde_json::from_str(&local_var_content).map_err(Error::from)
13488    } else {
13489        let local_var_entity: Option<IpamRouteTargetsUpdateError> =
13490            serde_json::from_str(&local_var_content).ok();
13491        let local_var_error = ResponseContent {
13492            status: local_var_status,
13493            content: local_var_content,
13494            entity: local_var_entity,
13495        };
13496        Err(Error::ResponseError(local_var_error))
13497    }
13498}
13499
13500/// Destroy a list of service objects.
13501pub async fn ipam_services_bulk_destroy(
13502    configuration: &configuration::Configuration,
13503    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
13504    format: Option<&str>,
13505) -> Result<(), Error<IpamServicesBulkDestroyError>> {
13506    let local_var_configuration = configuration;
13507
13508    let local_var_client = &local_var_configuration.client;
13509
13510    let local_var_uri_str = format!("{}/ipam/services/", local_var_configuration.base_path);
13511    let mut local_var_req_builder =
13512        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13513
13514    if let Some(ref local_var_str) = format {
13515        local_var_req_builder =
13516            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13517    }
13518    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13519        local_var_req_builder =
13520            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13521    }
13522    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13523        let local_var_key = local_var_apikey.key.clone();
13524        let local_var_value = match local_var_apikey.prefix {
13525            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13526            None => local_var_key,
13527        };
13528        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13529    };
13530    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
13531
13532    let local_var_req = local_var_req_builder.build()?;
13533    let local_var_resp = local_var_client.execute(local_var_req).await?;
13534
13535    let local_var_status = local_var_resp.status();
13536    let local_var_content = local_var_resp.text().await?;
13537
13538    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13539        Ok(())
13540    } else {
13541        let local_var_entity: Option<IpamServicesBulkDestroyError> =
13542            serde_json::from_str(&local_var_content).ok();
13543        let local_var_error = ResponseContent {
13544            status: local_var_status,
13545            content: local_var_content,
13546            entity: local_var_entity,
13547        };
13548        Err(Error::ResponseError(local_var_error))
13549    }
13550}
13551
13552/// Partial update a list of service objects.
13553pub async fn ipam_services_bulk_partial_update(
13554    configuration: &configuration::Configuration,
13555    patched_bulk_writable_service_request: Vec<crate::models::PatchedBulkWritableServiceRequest>,
13556    format: Option<&str>,
13557) -> Result<Vec<crate::models::Service>, Error<IpamServicesBulkPartialUpdateError>> {
13558    let local_var_configuration = configuration;
13559
13560    let local_var_client = &local_var_configuration.client;
13561
13562    let local_var_uri_str = format!("{}/ipam/services/", local_var_configuration.base_path);
13563    let mut local_var_req_builder =
13564        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13565
13566    if let Some(ref local_var_str) = format {
13567        local_var_req_builder =
13568            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13569    }
13570    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13571        local_var_req_builder =
13572            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13573    }
13574    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13575        let local_var_key = local_var_apikey.key.clone();
13576        let local_var_value = match local_var_apikey.prefix {
13577            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13578            None => local_var_key,
13579        };
13580        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13581    };
13582    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_service_request);
13583
13584    let local_var_req = local_var_req_builder.build()?;
13585    let local_var_resp = local_var_client.execute(local_var_req).await?;
13586
13587    let local_var_status = local_var_resp.status();
13588    let local_var_content = local_var_resp.text().await?;
13589
13590    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13591        serde_json::from_str(&local_var_content).map_err(Error::from)
13592    } else {
13593        let local_var_entity: Option<IpamServicesBulkPartialUpdateError> =
13594            serde_json::from_str(&local_var_content).ok();
13595        let local_var_error = ResponseContent {
13596            status: local_var_status,
13597            content: local_var_content,
13598            entity: local_var_entity,
13599        };
13600        Err(Error::ResponseError(local_var_error))
13601    }
13602}
13603
13604/// Update a list of service objects.
13605pub async fn ipam_services_bulk_update(
13606    configuration: &configuration::Configuration,
13607    bulk_writable_service_request: Vec<crate::models::BulkWritableServiceRequest>,
13608    format: Option<&str>,
13609) -> Result<Vec<crate::models::Service>, Error<IpamServicesBulkUpdateError>> {
13610    let local_var_configuration = configuration;
13611
13612    let local_var_client = &local_var_configuration.client;
13613
13614    let local_var_uri_str = format!("{}/ipam/services/", local_var_configuration.base_path);
13615    let mut local_var_req_builder =
13616        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13617
13618    if let Some(ref local_var_str) = format {
13619        local_var_req_builder =
13620            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13621    }
13622    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13623        local_var_req_builder =
13624            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13625    }
13626    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13627        let local_var_key = local_var_apikey.key.clone();
13628        let local_var_value = match local_var_apikey.prefix {
13629            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13630            None => local_var_key,
13631        };
13632        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13633    };
13634    local_var_req_builder = local_var_req_builder.json(&bulk_writable_service_request);
13635
13636    let local_var_req = local_var_req_builder.build()?;
13637    let local_var_resp = local_var_client.execute(local_var_req).await?;
13638
13639    let local_var_status = local_var_resp.status();
13640    let local_var_content = local_var_resp.text().await?;
13641
13642    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13643        serde_json::from_str(&local_var_content).map_err(Error::from)
13644    } else {
13645        let local_var_entity: Option<IpamServicesBulkUpdateError> =
13646            serde_json::from_str(&local_var_content).ok();
13647        let local_var_error = ResponseContent {
13648            status: local_var_status,
13649            content: local_var_content,
13650            entity: local_var_entity,
13651        };
13652        Err(Error::ResponseError(local_var_error))
13653    }
13654}
13655
13656/// Create one or more service objects.
13657pub async fn ipam_services_create(
13658    configuration: &configuration::Configuration,
13659    writable_service_request: crate::models::WritableServiceRequest,
13660    format: Option<&str>,
13661) -> Result<crate::models::Service, Error<IpamServicesCreateError>> {
13662    let local_var_configuration = configuration;
13663
13664    let local_var_client = &local_var_configuration.client;
13665
13666    let local_var_uri_str = format!("{}/ipam/services/", local_var_configuration.base_path);
13667    let mut local_var_req_builder =
13668        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13669
13670    if let Some(ref local_var_str) = format {
13671        local_var_req_builder =
13672            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13673    }
13674    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13675        local_var_req_builder =
13676            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13677    }
13678    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13679        let local_var_key = local_var_apikey.key.clone();
13680        let local_var_value = match local_var_apikey.prefix {
13681            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13682            None => local_var_key,
13683        };
13684        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13685    };
13686    local_var_req_builder = local_var_req_builder.json(&writable_service_request);
13687
13688    let local_var_req = local_var_req_builder.build()?;
13689    let local_var_resp = local_var_client.execute(local_var_req).await?;
13690
13691    let local_var_status = local_var_resp.status();
13692    let local_var_content = local_var_resp.text().await?;
13693
13694    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13695        serde_json::from_str(&local_var_content).map_err(Error::from)
13696    } else {
13697        let local_var_entity: Option<IpamServicesCreateError> =
13698            serde_json::from_str(&local_var_content).ok();
13699        let local_var_error = ResponseContent {
13700            status: local_var_status,
13701            content: local_var_content,
13702            entity: local_var_entity,
13703        };
13704        Err(Error::ResponseError(local_var_error))
13705    }
13706}
13707
13708/// Destroy a service object.
13709pub async fn ipam_services_destroy(
13710    configuration: &configuration::Configuration,
13711    id: &str,
13712    format: Option<&str>,
13713) -> Result<(), Error<IpamServicesDestroyError>> {
13714    let local_var_configuration = configuration;
13715
13716    let local_var_client = &local_var_configuration.client;
13717
13718    let local_var_uri_str = format!(
13719        "{}/ipam/services/{id}/",
13720        local_var_configuration.base_path,
13721        id = crate::apis::urlencode(id)
13722    );
13723    let mut local_var_req_builder =
13724        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13725
13726    if let Some(ref local_var_str) = format {
13727        local_var_req_builder =
13728            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13729    }
13730    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13731        local_var_req_builder =
13732            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13733    }
13734    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13735        let local_var_key = local_var_apikey.key.clone();
13736        let local_var_value = match local_var_apikey.prefix {
13737            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13738            None => local_var_key,
13739        };
13740        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13741    };
13742
13743    let local_var_req = local_var_req_builder.build()?;
13744    let local_var_resp = local_var_client.execute(local_var_req).await?;
13745
13746    let local_var_status = local_var_resp.status();
13747    let local_var_content = local_var_resp.text().await?;
13748
13749    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13750        Ok(())
13751    } else {
13752        let local_var_entity: Option<IpamServicesDestroyError> =
13753            serde_json::from_str(&local_var_content).ok();
13754        let local_var_error = ResponseContent {
13755            status: local_var_status,
13756            content: local_var_content,
13757            entity: local_var_entity,
13758        };
13759        Err(Error::ResponseError(local_var_error))
13760    }
13761}
13762
13763/// Retrieve a list of service objects.
13764pub async fn ipam_services_list(
13765    configuration: &configuration::Configuration,
13766    contacts: Option<Vec<String>>,
13767    contacts__isnull: Option<bool>,
13768    contacts__n: Option<Vec<String>>,
13769    created: Option<Vec<String>>,
13770    created__gt: Option<Vec<String>>,
13771    created__gte: Option<Vec<String>>,
13772    created__isnull: Option<bool>,
13773    created__lt: Option<Vec<String>>,
13774    created__lte: Option<Vec<String>>,
13775    created__n: Option<Vec<String>>,
13776    device: Option<Vec<String>>,
13777    device__isnull: Option<bool>,
13778    device__n: Option<Vec<String>>,
13779    dynamic_groups: Option<Vec<String>>,
13780    dynamic_groups__n: Option<Vec<String>>,
13781    format: Option<&str>,
13782    id: Option<Vec<uuid::Uuid>>,
13783    id__n: Option<Vec<uuid::Uuid>>,
13784    last_updated: Option<Vec<String>>,
13785    last_updated__gt: Option<Vec<String>>,
13786    last_updated__gte: Option<Vec<String>>,
13787    last_updated__isnull: Option<bool>,
13788    last_updated__lt: Option<Vec<String>>,
13789    last_updated__lte: Option<Vec<String>>,
13790    last_updated__n: Option<Vec<String>>,
13791    limit: Option<i32>,
13792    name: Option<Vec<String>>,
13793    name__ic: Option<Vec<String>>,
13794    name__ie: Option<Vec<String>>,
13795    name__iew: Option<Vec<String>>,
13796    name__ire: Option<Vec<String>>,
13797    name__isw: Option<Vec<String>>,
13798    name__n: Option<Vec<String>>,
13799    name__nic: Option<Vec<String>>,
13800    name__nie: Option<Vec<String>>,
13801    name__niew: Option<Vec<String>>,
13802    name__nire: Option<Vec<String>>,
13803    name__nisw: Option<Vec<String>>,
13804    name__nre: Option<Vec<String>>,
13805    name__re: Option<Vec<String>>,
13806    offset: Option<i32>,
13807    ports: Option<f32>,
13808    protocol: Option<Vec<String>>,
13809    protocol__ic: Option<Vec<String>>,
13810    protocol__ie: Option<Vec<String>>,
13811    protocol__iew: Option<Vec<String>>,
13812    protocol__ire: Option<Vec<String>>,
13813    protocol__isw: Option<Vec<String>>,
13814    protocol__n: Option<Vec<String>>,
13815    protocol__nic: Option<Vec<String>>,
13816    protocol__nie: Option<Vec<String>>,
13817    protocol__niew: Option<Vec<String>>,
13818    protocol__nire: Option<Vec<String>>,
13819    protocol__nisw: Option<Vec<String>>,
13820    protocol__nre: Option<Vec<String>>,
13821    protocol__re: Option<Vec<String>>,
13822    q: Option<&str>,
13823    sort: Option<&str>,
13824    tags: Option<Vec<String>>,
13825    tags__isnull: Option<bool>,
13826    tags__n: Option<Vec<String>>,
13827    teams: Option<Vec<String>>,
13828    teams__isnull: Option<bool>,
13829    teams__n: Option<Vec<String>>,
13830    virtual_machine: Option<Vec<String>>,
13831    virtual_machine__isnull: Option<bool>,
13832    virtual_machine__n: Option<Vec<String>>,
13833    depth: Option<i32>,
13834    exclude_m2m: Option<bool>,
13835) -> Result<crate::models::PaginatedServiceList, Error<IpamServicesListError>> {
13836    let local_var_configuration = configuration;
13837
13838    let local_var_client = &local_var_configuration.client;
13839
13840    let local_var_uri_str = format!("{}/ipam/services/", local_var_configuration.base_path);
13841    let mut local_var_req_builder =
13842        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13843
13844    if let Some(ref local_var_str) = contacts {
13845        local_var_req_builder = match "multi" {
13846            "multi" => local_var_req_builder.query(
13847                &local_var_str
13848                    .into_iter()
13849                    .map(|p| ("contacts".to_owned(), p.to_string()))
13850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13851            ),
13852            _ => local_var_req_builder.query(&[(
13853                "contacts",
13854                &local_var_str
13855                    .into_iter()
13856                    .map(|p| p.to_string())
13857                    .collect::<Vec<String>>()
13858                    .join(",")
13859                    .to_string(),
13860            )]),
13861        };
13862    }
13863    if let Some(ref local_var_str) = contacts__isnull {
13864        local_var_req_builder =
13865            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
13866    }
13867    if let Some(ref local_var_str) = contacts__n {
13868        local_var_req_builder = match "multi" {
13869            "multi" => local_var_req_builder.query(
13870                &local_var_str
13871                    .into_iter()
13872                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
13873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13874            ),
13875            _ => local_var_req_builder.query(&[(
13876                "contacts__n",
13877                &local_var_str
13878                    .into_iter()
13879                    .map(|p| p.to_string())
13880                    .collect::<Vec<String>>()
13881                    .join(",")
13882                    .to_string(),
13883            )]),
13884        };
13885    }
13886    if let Some(ref local_var_str) = created {
13887        local_var_req_builder = match "multi" {
13888            "multi" => local_var_req_builder.query(
13889                &local_var_str
13890                    .into_iter()
13891                    .map(|p| ("created".to_owned(), p.to_string()))
13892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13893            ),
13894            _ => local_var_req_builder.query(&[(
13895                "created",
13896                &local_var_str
13897                    .into_iter()
13898                    .map(|p| p.to_string())
13899                    .collect::<Vec<String>>()
13900                    .join(",")
13901                    .to_string(),
13902            )]),
13903        };
13904    }
13905    if let Some(ref local_var_str) = created__gt {
13906        local_var_req_builder = match "multi" {
13907            "multi" => local_var_req_builder.query(
13908                &local_var_str
13909                    .into_iter()
13910                    .map(|p| ("created__gt".to_owned(), p.to_string()))
13911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13912            ),
13913            _ => local_var_req_builder.query(&[(
13914                "created__gt",
13915                &local_var_str
13916                    .into_iter()
13917                    .map(|p| p.to_string())
13918                    .collect::<Vec<String>>()
13919                    .join(",")
13920                    .to_string(),
13921            )]),
13922        };
13923    }
13924    if let Some(ref local_var_str) = created__gte {
13925        local_var_req_builder = match "multi" {
13926            "multi" => local_var_req_builder.query(
13927                &local_var_str
13928                    .into_iter()
13929                    .map(|p| ("created__gte".to_owned(), p.to_string()))
13930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13931            ),
13932            _ => local_var_req_builder.query(&[(
13933                "created__gte",
13934                &local_var_str
13935                    .into_iter()
13936                    .map(|p| p.to_string())
13937                    .collect::<Vec<String>>()
13938                    .join(",")
13939                    .to_string(),
13940            )]),
13941        };
13942    }
13943    if let Some(ref local_var_str) = created__isnull {
13944        local_var_req_builder =
13945            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
13946    }
13947    if let Some(ref local_var_str) = created__lt {
13948        local_var_req_builder = match "multi" {
13949            "multi" => local_var_req_builder.query(
13950                &local_var_str
13951                    .into_iter()
13952                    .map(|p| ("created__lt".to_owned(), p.to_string()))
13953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13954            ),
13955            _ => local_var_req_builder.query(&[(
13956                "created__lt",
13957                &local_var_str
13958                    .into_iter()
13959                    .map(|p| p.to_string())
13960                    .collect::<Vec<String>>()
13961                    .join(",")
13962                    .to_string(),
13963            )]),
13964        };
13965    }
13966    if let Some(ref local_var_str) = created__lte {
13967        local_var_req_builder = match "multi" {
13968            "multi" => local_var_req_builder.query(
13969                &local_var_str
13970                    .into_iter()
13971                    .map(|p| ("created__lte".to_owned(), p.to_string()))
13972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13973            ),
13974            _ => local_var_req_builder.query(&[(
13975                "created__lte",
13976                &local_var_str
13977                    .into_iter()
13978                    .map(|p| p.to_string())
13979                    .collect::<Vec<String>>()
13980                    .join(",")
13981                    .to_string(),
13982            )]),
13983        };
13984    }
13985    if let Some(ref local_var_str) = created__n {
13986        local_var_req_builder = match "multi" {
13987            "multi" => local_var_req_builder.query(
13988                &local_var_str
13989                    .into_iter()
13990                    .map(|p| ("created__n".to_owned(), p.to_string()))
13991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13992            ),
13993            _ => local_var_req_builder.query(&[(
13994                "created__n",
13995                &local_var_str
13996                    .into_iter()
13997                    .map(|p| p.to_string())
13998                    .collect::<Vec<String>>()
13999                    .join(",")
14000                    .to_string(),
14001            )]),
14002        };
14003    }
14004    if let Some(ref local_var_str) = device {
14005        local_var_req_builder = match "multi" {
14006            "multi" => local_var_req_builder.query(
14007                &local_var_str
14008                    .into_iter()
14009                    .map(|p| ("device".to_owned(), p.to_string()))
14010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14011            ),
14012            _ => local_var_req_builder.query(&[(
14013                "device",
14014                &local_var_str
14015                    .into_iter()
14016                    .map(|p| p.to_string())
14017                    .collect::<Vec<String>>()
14018                    .join(",")
14019                    .to_string(),
14020            )]),
14021        };
14022    }
14023    if let Some(ref local_var_str) = device__isnull {
14024        local_var_req_builder =
14025            local_var_req_builder.query(&[("device__isnull", &local_var_str.to_string())]);
14026    }
14027    if let Some(ref local_var_str) = device__n {
14028        local_var_req_builder = match "multi" {
14029            "multi" => local_var_req_builder.query(
14030                &local_var_str
14031                    .into_iter()
14032                    .map(|p| ("device__n".to_owned(), p.to_string()))
14033                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14034            ),
14035            _ => local_var_req_builder.query(&[(
14036                "device__n",
14037                &local_var_str
14038                    .into_iter()
14039                    .map(|p| p.to_string())
14040                    .collect::<Vec<String>>()
14041                    .join(",")
14042                    .to_string(),
14043            )]),
14044        };
14045    }
14046    if let Some(ref local_var_str) = dynamic_groups {
14047        local_var_req_builder = match "multi" {
14048            "multi" => local_var_req_builder.query(
14049                &local_var_str
14050                    .into_iter()
14051                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
14052                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14053            ),
14054            _ => local_var_req_builder.query(&[(
14055                "dynamic_groups",
14056                &local_var_str
14057                    .into_iter()
14058                    .map(|p| p.to_string())
14059                    .collect::<Vec<String>>()
14060                    .join(",")
14061                    .to_string(),
14062            )]),
14063        };
14064    }
14065    if let Some(ref local_var_str) = dynamic_groups__n {
14066        local_var_req_builder = match "multi" {
14067            "multi" => local_var_req_builder.query(
14068                &local_var_str
14069                    .into_iter()
14070                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
14071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14072            ),
14073            _ => local_var_req_builder.query(&[(
14074                "dynamic_groups__n",
14075                &local_var_str
14076                    .into_iter()
14077                    .map(|p| p.to_string())
14078                    .collect::<Vec<String>>()
14079                    .join(",")
14080                    .to_string(),
14081            )]),
14082        };
14083    }
14084    if let Some(ref local_var_str) = format {
14085        local_var_req_builder =
14086            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14087    }
14088    if let Some(ref local_var_str) = id {
14089        local_var_req_builder = match "multi" {
14090            "multi" => local_var_req_builder.query(
14091                &local_var_str
14092                    .into_iter()
14093                    .map(|p| ("id".to_owned(), p.to_string()))
14094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14095            ),
14096            _ => local_var_req_builder.query(&[(
14097                "id",
14098                &local_var_str
14099                    .into_iter()
14100                    .map(|p| p.to_string())
14101                    .collect::<Vec<String>>()
14102                    .join(",")
14103                    .to_string(),
14104            )]),
14105        };
14106    }
14107    if let Some(ref local_var_str) = id__n {
14108        local_var_req_builder = match "multi" {
14109            "multi" => local_var_req_builder.query(
14110                &local_var_str
14111                    .into_iter()
14112                    .map(|p| ("id__n".to_owned(), p.to_string()))
14113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14114            ),
14115            _ => local_var_req_builder.query(&[(
14116                "id__n",
14117                &local_var_str
14118                    .into_iter()
14119                    .map(|p| p.to_string())
14120                    .collect::<Vec<String>>()
14121                    .join(",")
14122                    .to_string(),
14123            )]),
14124        };
14125    }
14126    if let Some(ref local_var_str) = last_updated {
14127        local_var_req_builder = match "multi" {
14128            "multi" => local_var_req_builder.query(
14129                &local_var_str
14130                    .into_iter()
14131                    .map(|p| ("last_updated".to_owned(), p.to_string()))
14132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14133            ),
14134            _ => local_var_req_builder.query(&[(
14135                "last_updated",
14136                &local_var_str
14137                    .into_iter()
14138                    .map(|p| p.to_string())
14139                    .collect::<Vec<String>>()
14140                    .join(",")
14141                    .to_string(),
14142            )]),
14143        };
14144    }
14145    if let Some(ref local_var_str) = last_updated__gt {
14146        local_var_req_builder = match "multi" {
14147            "multi" => local_var_req_builder.query(
14148                &local_var_str
14149                    .into_iter()
14150                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
14151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14152            ),
14153            _ => local_var_req_builder.query(&[(
14154                "last_updated__gt",
14155                &local_var_str
14156                    .into_iter()
14157                    .map(|p| p.to_string())
14158                    .collect::<Vec<String>>()
14159                    .join(",")
14160                    .to_string(),
14161            )]),
14162        };
14163    }
14164    if let Some(ref local_var_str) = last_updated__gte {
14165        local_var_req_builder = match "multi" {
14166            "multi" => local_var_req_builder.query(
14167                &local_var_str
14168                    .into_iter()
14169                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
14170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14171            ),
14172            _ => local_var_req_builder.query(&[(
14173                "last_updated__gte",
14174                &local_var_str
14175                    .into_iter()
14176                    .map(|p| p.to_string())
14177                    .collect::<Vec<String>>()
14178                    .join(",")
14179                    .to_string(),
14180            )]),
14181        };
14182    }
14183    if let Some(ref local_var_str) = last_updated__isnull {
14184        local_var_req_builder =
14185            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
14186    }
14187    if let Some(ref local_var_str) = last_updated__lt {
14188        local_var_req_builder = match "multi" {
14189            "multi" => local_var_req_builder.query(
14190                &local_var_str
14191                    .into_iter()
14192                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
14193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14194            ),
14195            _ => local_var_req_builder.query(&[(
14196                "last_updated__lt",
14197                &local_var_str
14198                    .into_iter()
14199                    .map(|p| p.to_string())
14200                    .collect::<Vec<String>>()
14201                    .join(",")
14202                    .to_string(),
14203            )]),
14204        };
14205    }
14206    if let Some(ref local_var_str) = last_updated__lte {
14207        local_var_req_builder = match "multi" {
14208            "multi" => local_var_req_builder.query(
14209                &local_var_str
14210                    .into_iter()
14211                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
14212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14213            ),
14214            _ => local_var_req_builder.query(&[(
14215                "last_updated__lte",
14216                &local_var_str
14217                    .into_iter()
14218                    .map(|p| p.to_string())
14219                    .collect::<Vec<String>>()
14220                    .join(",")
14221                    .to_string(),
14222            )]),
14223        };
14224    }
14225    if let Some(ref local_var_str) = last_updated__n {
14226        local_var_req_builder = match "multi" {
14227            "multi" => local_var_req_builder.query(
14228                &local_var_str
14229                    .into_iter()
14230                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
14231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14232            ),
14233            _ => local_var_req_builder.query(&[(
14234                "last_updated__n",
14235                &local_var_str
14236                    .into_iter()
14237                    .map(|p| p.to_string())
14238                    .collect::<Vec<String>>()
14239                    .join(",")
14240                    .to_string(),
14241            )]),
14242        };
14243    }
14244    if let Some(ref local_var_str) = limit {
14245        local_var_req_builder =
14246            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
14247    }
14248    if let Some(ref local_var_str) = name {
14249        local_var_req_builder = match "multi" {
14250            "multi" => local_var_req_builder.query(
14251                &local_var_str
14252                    .into_iter()
14253                    .map(|p| ("name".to_owned(), p.to_string()))
14254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14255            ),
14256            _ => local_var_req_builder.query(&[(
14257                "name",
14258                &local_var_str
14259                    .into_iter()
14260                    .map(|p| p.to_string())
14261                    .collect::<Vec<String>>()
14262                    .join(",")
14263                    .to_string(),
14264            )]),
14265        };
14266    }
14267    if let Some(ref local_var_str) = name__ic {
14268        local_var_req_builder = match "multi" {
14269            "multi" => local_var_req_builder.query(
14270                &local_var_str
14271                    .into_iter()
14272                    .map(|p| ("name__ic".to_owned(), p.to_string()))
14273                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14274            ),
14275            _ => local_var_req_builder.query(&[(
14276                "name__ic",
14277                &local_var_str
14278                    .into_iter()
14279                    .map(|p| p.to_string())
14280                    .collect::<Vec<String>>()
14281                    .join(",")
14282                    .to_string(),
14283            )]),
14284        };
14285    }
14286    if let Some(ref local_var_str) = name__ie {
14287        local_var_req_builder = match "multi" {
14288            "multi" => local_var_req_builder.query(
14289                &local_var_str
14290                    .into_iter()
14291                    .map(|p| ("name__ie".to_owned(), p.to_string()))
14292                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14293            ),
14294            _ => local_var_req_builder.query(&[(
14295                "name__ie",
14296                &local_var_str
14297                    .into_iter()
14298                    .map(|p| p.to_string())
14299                    .collect::<Vec<String>>()
14300                    .join(",")
14301                    .to_string(),
14302            )]),
14303        };
14304    }
14305    if let Some(ref local_var_str) = name__iew {
14306        local_var_req_builder = match "multi" {
14307            "multi" => local_var_req_builder.query(
14308                &local_var_str
14309                    .into_iter()
14310                    .map(|p| ("name__iew".to_owned(), p.to_string()))
14311                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14312            ),
14313            _ => local_var_req_builder.query(&[(
14314                "name__iew",
14315                &local_var_str
14316                    .into_iter()
14317                    .map(|p| p.to_string())
14318                    .collect::<Vec<String>>()
14319                    .join(",")
14320                    .to_string(),
14321            )]),
14322        };
14323    }
14324    if let Some(ref local_var_str) = name__ire {
14325        local_var_req_builder = match "multi" {
14326            "multi" => local_var_req_builder.query(
14327                &local_var_str
14328                    .into_iter()
14329                    .map(|p| ("name__ire".to_owned(), p.to_string()))
14330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14331            ),
14332            _ => local_var_req_builder.query(&[(
14333                "name__ire",
14334                &local_var_str
14335                    .into_iter()
14336                    .map(|p| p.to_string())
14337                    .collect::<Vec<String>>()
14338                    .join(",")
14339                    .to_string(),
14340            )]),
14341        };
14342    }
14343    if let Some(ref local_var_str) = name__isw {
14344        local_var_req_builder = match "multi" {
14345            "multi" => local_var_req_builder.query(
14346                &local_var_str
14347                    .into_iter()
14348                    .map(|p| ("name__isw".to_owned(), p.to_string()))
14349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14350            ),
14351            _ => local_var_req_builder.query(&[(
14352                "name__isw",
14353                &local_var_str
14354                    .into_iter()
14355                    .map(|p| p.to_string())
14356                    .collect::<Vec<String>>()
14357                    .join(",")
14358                    .to_string(),
14359            )]),
14360        };
14361    }
14362    if let Some(ref local_var_str) = name__n {
14363        local_var_req_builder = match "multi" {
14364            "multi" => local_var_req_builder.query(
14365                &local_var_str
14366                    .into_iter()
14367                    .map(|p| ("name__n".to_owned(), p.to_string()))
14368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14369            ),
14370            _ => local_var_req_builder.query(&[(
14371                "name__n",
14372                &local_var_str
14373                    .into_iter()
14374                    .map(|p| p.to_string())
14375                    .collect::<Vec<String>>()
14376                    .join(",")
14377                    .to_string(),
14378            )]),
14379        };
14380    }
14381    if let Some(ref local_var_str) = name__nic {
14382        local_var_req_builder = match "multi" {
14383            "multi" => local_var_req_builder.query(
14384                &local_var_str
14385                    .into_iter()
14386                    .map(|p| ("name__nic".to_owned(), p.to_string()))
14387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14388            ),
14389            _ => local_var_req_builder.query(&[(
14390                "name__nic",
14391                &local_var_str
14392                    .into_iter()
14393                    .map(|p| p.to_string())
14394                    .collect::<Vec<String>>()
14395                    .join(",")
14396                    .to_string(),
14397            )]),
14398        };
14399    }
14400    if let Some(ref local_var_str) = name__nie {
14401        local_var_req_builder = match "multi" {
14402            "multi" => local_var_req_builder.query(
14403                &local_var_str
14404                    .into_iter()
14405                    .map(|p| ("name__nie".to_owned(), p.to_string()))
14406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14407            ),
14408            _ => local_var_req_builder.query(&[(
14409                "name__nie",
14410                &local_var_str
14411                    .into_iter()
14412                    .map(|p| p.to_string())
14413                    .collect::<Vec<String>>()
14414                    .join(",")
14415                    .to_string(),
14416            )]),
14417        };
14418    }
14419    if let Some(ref local_var_str) = name__niew {
14420        local_var_req_builder = match "multi" {
14421            "multi" => local_var_req_builder.query(
14422                &local_var_str
14423                    .into_iter()
14424                    .map(|p| ("name__niew".to_owned(), p.to_string()))
14425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14426            ),
14427            _ => local_var_req_builder.query(&[(
14428                "name__niew",
14429                &local_var_str
14430                    .into_iter()
14431                    .map(|p| p.to_string())
14432                    .collect::<Vec<String>>()
14433                    .join(",")
14434                    .to_string(),
14435            )]),
14436        };
14437    }
14438    if let Some(ref local_var_str) = name__nire {
14439        local_var_req_builder = match "multi" {
14440            "multi" => local_var_req_builder.query(
14441                &local_var_str
14442                    .into_iter()
14443                    .map(|p| ("name__nire".to_owned(), p.to_string()))
14444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14445            ),
14446            _ => local_var_req_builder.query(&[(
14447                "name__nire",
14448                &local_var_str
14449                    .into_iter()
14450                    .map(|p| p.to_string())
14451                    .collect::<Vec<String>>()
14452                    .join(",")
14453                    .to_string(),
14454            )]),
14455        };
14456    }
14457    if let Some(ref local_var_str) = name__nisw {
14458        local_var_req_builder = match "multi" {
14459            "multi" => local_var_req_builder.query(
14460                &local_var_str
14461                    .into_iter()
14462                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
14463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14464            ),
14465            _ => local_var_req_builder.query(&[(
14466                "name__nisw",
14467                &local_var_str
14468                    .into_iter()
14469                    .map(|p| p.to_string())
14470                    .collect::<Vec<String>>()
14471                    .join(",")
14472                    .to_string(),
14473            )]),
14474        };
14475    }
14476    if let Some(ref local_var_str) = name__nre {
14477        local_var_req_builder = match "multi" {
14478            "multi" => local_var_req_builder.query(
14479                &local_var_str
14480                    .into_iter()
14481                    .map(|p| ("name__nre".to_owned(), p.to_string()))
14482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14483            ),
14484            _ => local_var_req_builder.query(&[(
14485                "name__nre",
14486                &local_var_str
14487                    .into_iter()
14488                    .map(|p| p.to_string())
14489                    .collect::<Vec<String>>()
14490                    .join(",")
14491                    .to_string(),
14492            )]),
14493        };
14494    }
14495    if let Some(ref local_var_str) = name__re {
14496        local_var_req_builder = match "multi" {
14497            "multi" => local_var_req_builder.query(
14498                &local_var_str
14499                    .into_iter()
14500                    .map(|p| ("name__re".to_owned(), p.to_string()))
14501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14502            ),
14503            _ => local_var_req_builder.query(&[(
14504                "name__re",
14505                &local_var_str
14506                    .into_iter()
14507                    .map(|p| p.to_string())
14508                    .collect::<Vec<String>>()
14509                    .join(",")
14510                    .to_string(),
14511            )]),
14512        };
14513    }
14514    if let Some(ref local_var_str) = offset {
14515        local_var_req_builder =
14516            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
14517    }
14518    if let Some(ref local_var_str) = ports {
14519        local_var_req_builder =
14520            local_var_req_builder.query(&[("ports", &local_var_str.to_string())]);
14521    }
14522    if let Some(ref local_var_str) = protocol {
14523        local_var_req_builder = match "multi" {
14524            "multi" => local_var_req_builder.query(
14525                &local_var_str
14526                    .into_iter()
14527                    .map(|p| ("protocol".to_owned(), p.to_string()))
14528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14529            ),
14530            _ => local_var_req_builder.query(&[(
14531                "protocol",
14532                &local_var_str
14533                    .into_iter()
14534                    .map(|p| p.to_string())
14535                    .collect::<Vec<String>>()
14536                    .join(",")
14537                    .to_string(),
14538            )]),
14539        };
14540    }
14541    if let Some(ref local_var_str) = protocol__ic {
14542        local_var_req_builder = match "multi" {
14543            "multi" => local_var_req_builder.query(
14544                &local_var_str
14545                    .into_iter()
14546                    .map(|p| ("protocol__ic".to_owned(), p.to_string()))
14547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14548            ),
14549            _ => local_var_req_builder.query(&[(
14550                "protocol__ic",
14551                &local_var_str
14552                    .into_iter()
14553                    .map(|p| p.to_string())
14554                    .collect::<Vec<String>>()
14555                    .join(",")
14556                    .to_string(),
14557            )]),
14558        };
14559    }
14560    if let Some(ref local_var_str) = protocol__ie {
14561        local_var_req_builder = match "multi" {
14562            "multi" => local_var_req_builder.query(
14563                &local_var_str
14564                    .into_iter()
14565                    .map(|p| ("protocol__ie".to_owned(), p.to_string()))
14566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14567            ),
14568            _ => local_var_req_builder.query(&[(
14569                "protocol__ie",
14570                &local_var_str
14571                    .into_iter()
14572                    .map(|p| p.to_string())
14573                    .collect::<Vec<String>>()
14574                    .join(",")
14575                    .to_string(),
14576            )]),
14577        };
14578    }
14579    if let Some(ref local_var_str) = protocol__iew {
14580        local_var_req_builder = match "multi" {
14581            "multi" => local_var_req_builder.query(
14582                &local_var_str
14583                    .into_iter()
14584                    .map(|p| ("protocol__iew".to_owned(), p.to_string()))
14585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14586            ),
14587            _ => local_var_req_builder.query(&[(
14588                "protocol__iew",
14589                &local_var_str
14590                    .into_iter()
14591                    .map(|p| p.to_string())
14592                    .collect::<Vec<String>>()
14593                    .join(",")
14594                    .to_string(),
14595            )]),
14596        };
14597    }
14598    if let Some(ref local_var_str) = protocol__ire {
14599        local_var_req_builder = match "multi" {
14600            "multi" => local_var_req_builder.query(
14601                &local_var_str
14602                    .into_iter()
14603                    .map(|p| ("protocol__ire".to_owned(), p.to_string()))
14604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14605            ),
14606            _ => local_var_req_builder.query(&[(
14607                "protocol__ire",
14608                &local_var_str
14609                    .into_iter()
14610                    .map(|p| p.to_string())
14611                    .collect::<Vec<String>>()
14612                    .join(",")
14613                    .to_string(),
14614            )]),
14615        };
14616    }
14617    if let Some(ref local_var_str) = protocol__isw {
14618        local_var_req_builder = match "multi" {
14619            "multi" => local_var_req_builder.query(
14620                &local_var_str
14621                    .into_iter()
14622                    .map(|p| ("protocol__isw".to_owned(), p.to_string()))
14623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14624            ),
14625            _ => local_var_req_builder.query(&[(
14626                "protocol__isw",
14627                &local_var_str
14628                    .into_iter()
14629                    .map(|p| p.to_string())
14630                    .collect::<Vec<String>>()
14631                    .join(",")
14632                    .to_string(),
14633            )]),
14634        };
14635    }
14636    if let Some(ref local_var_str) = protocol__n {
14637        local_var_req_builder = match "multi" {
14638            "multi" => local_var_req_builder.query(
14639                &local_var_str
14640                    .into_iter()
14641                    .map(|p| ("protocol__n".to_owned(), p.to_string()))
14642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14643            ),
14644            _ => local_var_req_builder.query(&[(
14645                "protocol__n",
14646                &local_var_str
14647                    .into_iter()
14648                    .map(|p| p.to_string())
14649                    .collect::<Vec<String>>()
14650                    .join(",")
14651                    .to_string(),
14652            )]),
14653        };
14654    }
14655    if let Some(ref local_var_str) = protocol__nic {
14656        local_var_req_builder = match "multi" {
14657            "multi" => local_var_req_builder.query(
14658                &local_var_str
14659                    .into_iter()
14660                    .map(|p| ("protocol__nic".to_owned(), p.to_string()))
14661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14662            ),
14663            _ => local_var_req_builder.query(&[(
14664                "protocol__nic",
14665                &local_var_str
14666                    .into_iter()
14667                    .map(|p| p.to_string())
14668                    .collect::<Vec<String>>()
14669                    .join(",")
14670                    .to_string(),
14671            )]),
14672        };
14673    }
14674    if let Some(ref local_var_str) = protocol__nie {
14675        local_var_req_builder = match "multi" {
14676            "multi" => local_var_req_builder.query(
14677                &local_var_str
14678                    .into_iter()
14679                    .map(|p| ("protocol__nie".to_owned(), p.to_string()))
14680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14681            ),
14682            _ => local_var_req_builder.query(&[(
14683                "protocol__nie",
14684                &local_var_str
14685                    .into_iter()
14686                    .map(|p| p.to_string())
14687                    .collect::<Vec<String>>()
14688                    .join(",")
14689                    .to_string(),
14690            )]),
14691        };
14692    }
14693    if let Some(ref local_var_str) = protocol__niew {
14694        local_var_req_builder = match "multi" {
14695            "multi" => local_var_req_builder.query(
14696                &local_var_str
14697                    .into_iter()
14698                    .map(|p| ("protocol__niew".to_owned(), p.to_string()))
14699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14700            ),
14701            _ => local_var_req_builder.query(&[(
14702                "protocol__niew",
14703                &local_var_str
14704                    .into_iter()
14705                    .map(|p| p.to_string())
14706                    .collect::<Vec<String>>()
14707                    .join(",")
14708                    .to_string(),
14709            )]),
14710        };
14711    }
14712    if let Some(ref local_var_str) = protocol__nire {
14713        local_var_req_builder = match "multi" {
14714            "multi" => local_var_req_builder.query(
14715                &local_var_str
14716                    .into_iter()
14717                    .map(|p| ("protocol__nire".to_owned(), p.to_string()))
14718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14719            ),
14720            _ => local_var_req_builder.query(&[(
14721                "protocol__nire",
14722                &local_var_str
14723                    .into_iter()
14724                    .map(|p| p.to_string())
14725                    .collect::<Vec<String>>()
14726                    .join(",")
14727                    .to_string(),
14728            )]),
14729        };
14730    }
14731    if let Some(ref local_var_str) = protocol__nisw {
14732        local_var_req_builder = match "multi" {
14733            "multi" => local_var_req_builder.query(
14734                &local_var_str
14735                    .into_iter()
14736                    .map(|p| ("protocol__nisw".to_owned(), p.to_string()))
14737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14738            ),
14739            _ => local_var_req_builder.query(&[(
14740                "protocol__nisw",
14741                &local_var_str
14742                    .into_iter()
14743                    .map(|p| p.to_string())
14744                    .collect::<Vec<String>>()
14745                    .join(",")
14746                    .to_string(),
14747            )]),
14748        };
14749    }
14750    if let Some(ref local_var_str) = protocol__nre {
14751        local_var_req_builder = match "multi" {
14752            "multi" => local_var_req_builder.query(
14753                &local_var_str
14754                    .into_iter()
14755                    .map(|p| ("protocol__nre".to_owned(), p.to_string()))
14756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14757            ),
14758            _ => local_var_req_builder.query(&[(
14759                "protocol__nre",
14760                &local_var_str
14761                    .into_iter()
14762                    .map(|p| p.to_string())
14763                    .collect::<Vec<String>>()
14764                    .join(",")
14765                    .to_string(),
14766            )]),
14767        };
14768    }
14769    if let Some(ref local_var_str) = protocol__re {
14770        local_var_req_builder = match "multi" {
14771            "multi" => local_var_req_builder.query(
14772                &local_var_str
14773                    .into_iter()
14774                    .map(|p| ("protocol__re".to_owned(), p.to_string()))
14775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14776            ),
14777            _ => local_var_req_builder.query(&[(
14778                "protocol__re",
14779                &local_var_str
14780                    .into_iter()
14781                    .map(|p| p.to_string())
14782                    .collect::<Vec<String>>()
14783                    .join(",")
14784                    .to_string(),
14785            )]),
14786        };
14787    }
14788    if let Some(ref local_var_str) = q {
14789        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
14790    }
14791    if let Some(ref local_var_str) = sort {
14792        local_var_req_builder =
14793            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
14794    }
14795    if let Some(ref local_var_str) = tags {
14796        local_var_req_builder = match "multi" {
14797            "multi" => local_var_req_builder.query(
14798                &local_var_str
14799                    .into_iter()
14800                    .map(|p| ("tags".to_owned(), p.to_string()))
14801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14802            ),
14803            _ => local_var_req_builder.query(&[(
14804                "tags",
14805                &local_var_str
14806                    .into_iter()
14807                    .map(|p| p.to_string())
14808                    .collect::<Vec<String>>()
14809                    .join(",")
14810                    .to_string(),
14811            )]),
14812        };
14813    }
14814    if let Some(ref local_var_str) = tags__isnull {
14815        local_var_req_builder =
14816            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
14817    }
14818    if let Some(ref local_var_str) = tags__n {
14819        local_var_req_builder = match "multi" {
14820            "multi" => local_var_req_builder.query(
14821                &local_var_str
14822                    .into_iter()
14823                    .map(|p| ("tags__n".to_owned(), p.to_string()))
14824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14825            ),
14826            _ => local_var_req_builder.query(&[(
14827                "tags__n",
14828                &local_var_str
14829                    .into_iter()
14830                    .map(|p| p.to_string())
14831                    .collect::<Vec<String>>()
14832                    .join(",")
14833                    .to_string(),
14834            )]),
14835        };
14836    }
14837    if let Some(ref local_var_str) = teams {
14838        local_var_req_builder = match "multi" {
14839            "multi" => local_var_req_builder.query(
14840                &local_var_str
14841                    .into_iter()
14842                    .map(|p| ("teams".to_owned(), p.to_string()))
14843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14844            ),
14845            _ => local_var_req_builder.query(&[(
14846                "teams",
14847                &local_var_str
14848                    .into_iter()
14849                    .map(|p| p.to_string())
14850                    .collect::<Vec<String>>()
14851                    .join(",")
14852                    .to_string(),
14853            )]),
14854        };
14855    }
14856    if let Some(ref local_var_str) = teams__isnull {
14857        local_var_req_builder =
14858            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
14859    }
14860    if let Some(ref local_var_str) = teams__n {
14861        local_var_req_builder = match "multi" {
14862            "multi" => local_var_req_builder.query(
14863                &local_var_str
14864                    .into_iter()
14865                    .map(|p| ("teams__n".to_owned(), p.to_string()))
14866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14867            ),
14868            _ => local_var_req_builder.query(&[(
14869                "teams__n",
14870                &local_var_str
14871                    .into_iter()
14872                    .map(|p| p.to_string())
14873                    .collect::<Vec<String>>()
14874                    .join(",")
14875                    .to_string(),
14876            )]),
14877        };
14878    }
14879    if let Some(ref local_var_str) = virtual_machine {
14880        local_var_req_builder = match "multi" {
14881            "multi" => local_var_req_builder.query(
14882                &local_var_str
14883                    .into_iter()
14884                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
14885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14886            ),
14887            _ => local_var_req_builder.query(&[(
14888                "virtual_machine",
14889                &local_var_str
14890                    .into_iter()
14891                    .map(|p| p.to_string())
14892                    .collect::<Vec<String>>()
14893                    .join(",")
14894                    .to_string(),
14895            )]),
14896        };
14897    }
14898    if let Some(ref local_var_str) = virtual_machine__isnull {
14899        local_var_req_builder =
14900            local_var_req_builder.query(&[("virtual_machine__isnull", &local_var_str.to_string())]);
14901    }
14902    if let Some(ref local_var_str) = virtual_machine__n {
14903        local_var_req_builder = match "multi" {
14904            "multi" => local_var_req_builder.query(
14905                &local_var_str
14906                    .into_iter()
14907                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
14908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14909            ),
14910            _ => local_var_req_builder.query(&[(
14911                "virtual_machine__n",
14912                &local_var_str
14913                    .into_iter()
14914                    .map(|p| p.to_string())
14915                    .collect::<Vec<String>>()
14916                    .join(",")
14917                    .to_string(),
14918            )]),
14919        };
14920    }
14921    if let Some(ref local_var_str) = depth {
14922        local_var_req_builder =
14923            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
14924    }
14925    if let Some(ref local_var_str) = exclude_m2m {
14926        local_var_req_builder =
14927            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
14928    }
14929    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14930        local_var_req_builder =
14931            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14932    }
14933    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14934        let local_var_key = local_var_apikey.key.clone();
14935        let local_var_value = match local_var_apikey.prefix {
14936            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14937            None => local_var_key,
14938        };
14939        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14940    };
14941
14942    let local_var_req = local_var_req_builder.build()?;
14943    let local_var_resp = local_var_client.execute(local_var_req).await?;
14944
14945    let local_var_status = local_var_resp.status();
14946    let local_var_content = local_var_resp.text().await?;
14947
14948    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14949        serde_json::from_str(&local_var_content).map_err(Error::from)
14950    } else {
14951        let local_var_entity: Option<IpamServicesListError> =
14952            serde_json::from_str(&local_var_content).ok();
14953        let local_var_error = ResponseContent {
14954            status: local_var_status,
14955            content: local_var_content,
14956            entity: local_var_entity,
14957        };
14958        Err(Error::ResponseError(local_var_error))
14959    }
14960}
14961
14962/// API methods for returning or creating notes on an object.
14963pub async fn ipam_services_notes_create(
14964    configuration: &configuration::Configuration,
14965    id: &str,
14966    note_input_request: crate::models::NoteInputRequest,
14967    format: Option<&str>,
14968) -> Result<crate::models::Note, Error<IpamServicesNotesCreateError>> {
14969    let local_var_configuration = configuration;
14970
14971    let local_var_client = &local_var_configuration.client;
14972
14973    let local_var_uri_str = format!(
14974        "{}/ipam/services/{id}/notes/",
14975        local_var_configuration.base_path,
14976        id = crate::apis::urlencode(id)
14977    );
14978    let mut local_var_req_builder =
14979        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
14980
14981    if let Some(ref local_var_str) = format {
14982        local_var_req_builder =
14983            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14984    }
14985    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14986        local_var_req_builder =
14987            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14988    }
14989    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14990        let local_var_key = local_var_apikey.key.clone();
14991        let local_var_value = match local_var_apikey.prefix {
14992            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14993            None => local_var_key,
14994        };
14995        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14996    };
14997    local_var_req_builder = local_var_req_builder.json(&note_input_request);
14998
14999    let local_var_req = local_var_req_builder.build()?;
15000    let local_var_resp = local_var_client.execute(local_var_req).await?;
15001
15002    let local_var_status = local_var_resp.status();
15003    let local_var_content = local_var_resp.text().await?;
15004
15005    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15006        serde_json::from_str(&local_var_content).map_err(Error::from)
15007    } else {
15008        let local_var_entity: Option<IpamServicesNotesCreateError> =
15009            serde_json::from_str(&local_var_content).ok();
15010        let local_var_error = ResponseContent {
15011            status: local_var_status,
15012            content: local_var_content,
15013            entity: local_var_entity,
15014        };
15015        Err(Error::ResponseError(local_var_error))
15016    }
15017}
15018
15019/// API methods for returning or creating notes on an object.
15020pub async fn ipam_services_notes_list(
15021    configuration: &configuration::Configuration,
15022    id: &str,
15023    format: Option<&str>,
15024    limit: Option<i32>,
15025    offset: Option<i32>,
15026    depth: Option<i32>,
15027    exclude_m2m: Option<bool>,
15028) -> Result<crate::models::PaginatedNoteList, Error<IpamServicesNotesListError>> {
15029    let local_var_configuration = configuration;
15030
15031    let local_var_client = &local_var_configuration.client;
15032
15033    let local_var_uri_str = format!(
15034        "{}/ipam/services/{id}/notes/",
15035        local_var_configuration.base_path,
15036        id = crate::apis::urlencode(id)
15037    );
15038    let mut local_var_req_builder =
15039        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15040
15041    if let Some(ref local_var_str) = format {
15042        local_var_req_builder =
15043            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15044    }
15045    if let Some(ref local_var_str) = limit {
15046        local_var_req_builder =
15047            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15048    }
15049    if let Some(ref local_var_str) = offset {
15050        local_var_req_builder =
15051            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
15052    }
15053    if let Some(ref local_var_str) = depth {
15054        local_var_req_builder =
15055            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
15056    }
15057    if let Some(ref local_var_str) = exclude_m2m {
15058        local_var_req_builder =
15059            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
15060    }
15061    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15062        local_var_req_builder =
15063            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15064    }
15065    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15066        let local_var_key = local_var_apikey.key.clone();
15067        let local_var_value = match local_var_apikey.prefix {
15068            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15069            None => local_var_key,
15070        };
15071        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15072    };
15073
15074    let local_var_req = local_var_req_builder.build()?;
15075    let local_var_resp = local_var_client.execute(local_var_req).await?;
15076
15077    let local_var_status = local_var_resp.status();
15078    let local_var_content = local_var_resp.text().await?;
15079
15080    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15081        serde_json::from_str(&local_var_content).map_err(Error::from)
15082    } else {
15083        let local_var_entity: Option<IpamServicesNotesListError> =
15084            serde_json::from_str(&local_var_content).ok();
15085        let local_var_error = ResponseContent {
15086            status: local_var_status,
15087            content: local_var_content,
15088            entity: local_var_entity,
15089        };
15090        Err(Error::ResponseError(local_var_error))
15091    }
15092}
15093
15094/// Partial update a service object.
15095pub async fn ipam_services_partial_update(
15096    configuration: &configuration::Configuration,
15097    id: &str,
15098    format: Option<&str>,
15099    patched_writable_service_request: Option<crate::models::PatchedWritableServiceRequest>,
15100) -> Result<crate::models::Service, Error<IpamServicesPartialUpdateError>> {
15101    let local_var_configuration = configuration;
15102
15103    let local_var_client = &local_var_configuration.client;
15104
15105    let local_var_uri_str = format!(
15106        "{}/ipam/services/{id}/",
15107        local_var_configuration.base_path,
15108        id = crate::apis::urlencode(id)
15109    );
15110    let mut local_var_req_builder =
15111        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15112
15113    if let Some(ref local_var_str) = format {
15114        local_var_req_builder =
15115            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15116    }
15117    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15118        local_var_req_builder =
15119            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15120    }
15121    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15122        let local_var_key = local_var_apikey.key.clone();
15123        let local_var_value = match local_var_apikey.prefix {
15124            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15125            None => local_var_key,
15126        };
15127        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15128    };
15129    local_var_req_builder = local_var_req_builder.json(&patched_writable_service_request);
15130
15131    let local_var_req = local_var_req_builder.build()?;
15132    let local_var_resp = local_var_client.execute(local_var_req).await?;
15133
15134    let local_var_status = local_var_resp.status();
15135    let local_var_content = local_var_resp.text().await?;
15136
15137    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15138        serde_json::from_str(&local_var_content).map_err(Error::from)
15139    } else {
15140        let local_var_entity: Option<IpamServicesPartialUpdateError> =
15141            serde_json::from_str(&local_var_content).ok();
15142        let local_var_error = ResponseContent {
15143            status: local_var_status,
15144            content: local_var_content,
15145            entity: local_var_entity,
15146        };
15147        Err(Error::ResponseError(local_var_error))
15148    }
15149}
15150
15151/// Retrieve a service object.
15152pub async fn ipam_services_retrieve(
15153    configuration: &configuration::Configuration,
15154    id: &str,
15155    format: Option<&str>,
15156    depth: Option<i32>,
15157    exclude_m2m: Option<bool>,
15158) -> Result<crate::models::Service, Error<IpamServicesRetrieveError>> {
15159    let local_var_configuration = configuration;
15160
15161    let local_var_client = &local_var_configuration.client;
15162
15163    let local_var_uri_str = format!(
15164        "{}/ipam/services/{id}/",
15165        local_var_configuration.base_path,
15166        id = crate::apis::urlencode(id)
15167    );
15168    let mut local_var_req_builder =
15169        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15170
15171    if let Some(ref local_var_str) = format {
15172        local_var_req_builder =
15173            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15174    }
15175    if let Some(ref local_var_str) = depth {
15176        local_var_req_builder =
15177            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
15178    }
15179    if let Some(ref local_var_str) = exclude_m2m {
15180        local_var_req_builder =
15181            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
15182    }
15183    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15184        local_var_req_builder =
15185            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15186    }
15187    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15188        let local_var_key = local_var_apikey.key.clone();
15189        let local_var_value = match local_var_apikey.prefix {
15190            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15191            None => local_var_key,
15192        };
15193        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15194    };
15195
15196    let local_var_req = local_var_req_builder.build()?;
15197    let local_var_resp = local_var_client.execute(local_var_req).await?;
15198
15199    let local_var_status = local_var_resp.status();
15200    let local_var_content = local_var_resp.text().await?;
15201
15202    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15203        serde_json::from_str(&local_var_content).map_err(Error::from)
15204    } else {
15205        let local_var_entity: Option<IpamServicesRetrieveError> =
15206            serde_json::from_str(&local_var_content).ok();
15207        let local_var_error = ResponseContent {
15208            status: local_var_status,
15209            content: local_var_content,
15210            entity: local_var_entity,
15211        };
15212        Err(Error::ResponseError(local_var_error))
15213    }
15214}
15215
15216/// Update a service object.
15217pub async fn ipam_services_update(
15218    configuration: &configuration::Configuration,
15219    id: &str,
15220    writable_service_request: crate::models::WritableServiceRequest,
15221    format: Option<&str>,
15222) -> Result<crate::models::Service, Error<IpamServicesUpdateError>> {
15223    let local_var_configuration = configuration;
15224
15225    let local_var_client = &local_var_configuration.client;
15226
15227    let local_var_uri_str = format!(
15228        "{}/ipam/services/{id}/",
15229        local_var_configuration.base_path,
15230        id = crate::apis::urlencode(id)
15231    );
15232    let mut local_var_req_builder =
15233        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15234
15235    if let Some(ref local_var_str) = format {
15236        local_var_req_builder =
15237            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15238    }
15239    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15240        local_var_req_builder =
15241            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15242    }
15243    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15244        let local_var_key = local_var_apikey.key.clone();
15245        let local_var_value = match local_var_apikey.prefix {
15246            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15247            None => local_var_key,
15248        };
15249        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15250    };
15251    local_var_req_builder = local_var_req_builder.json(&writable_service_request);
15252
15253    let local_var_req = local_var_req_builder.build()?;
15254    let local_var_resp = local_var_client.execute(local_var_req).await?;
15255
15256    let local_var_status = local_var_resp.status();
15257    let local_var_content = local_var_resp.text().await?;
15258
15259    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15260        serde_json::from_str(&local_var_content).map_err(Error::from)
15261    } else {
15262        let local_var_entity: Option<IpamServicesUpdateError> =
15263            serde_json::from_str(&local_var_content).ok();
15264        let local_var_error = ResponseContent {
15265            status: local_var_status,
15266            content: local_var_content,
15267            entity: local_var_entity,
15268        };
15269        Err(Error::ResponseError(local_var_error))
15270    }
15271}
15272
15273/// A convenience method for listing available VLAN IDs within a VLANGroup. By default, the number of VIDs returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.
15274pub async fn ipam_vlan_groups_available_vlans_create(
15275    configuration: &configuration::Configuration,
15276    id: &str,
15277    vlan_allocation_request: Vec<crate::models::VlanAllocationRequest>,
15278    format: Option<&str>,
15279    limit: Option<i32>,
15280    offset: Option<i32>,
15281    sort: Option<&str>,
15282) -> Result<crate::models::PaginatedVlanList, Error<IpamVlanGroupsAvailableVlansCreateError>> {
15283    let local_var_configuration = configuration;
15284
15285    let local_var_client = &local_var_configuration.client;
15286
15287    let local_var_uri_str = format!(
15288        "{}/ipam/vlan-groups/{id}/available-vlans/",
15289        local_var_configuration.base_path,
15290        id = crate::apis::urlencode(id)
15291    );
15292    let mut local_var_req_builder =
15293        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15294
15295    if let Some(ref local_var_str) = format {
15296        local_var_req_builder =
15297            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15298    }
15299    if let Some(ref local_var_str) = limit {
15300        local_var_req_builder =
15301            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15302    }
15303    if let Some(ref local_var_str) = offset {
15304        local_var_req_builder =
15305            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
15306    }
15307    if let Some(ref local_var_str) = sort {
15308        local_var_req_builder =
15309            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
15310    }
15311    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15312        local_var_req_builder =
15313            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15314    }
15315    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15316        let local_var_key = local_var_apikey.key.clone();
15317        let local_var_value = match local_var_apikey.prefix {
15318            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15319            None => local_var_key,
15320        };
15321        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15322    };
15323    local_var_req_builder = local_var_req_builder.json(&vlan_allocation_request);
15324
15325    let local_var_req = local_var_req_builder.build()?;
15326    let local_var_resp = local_var_client.execute(local_var_req).await?;
15327
15328    let local_var_status = local_var_resp.status();
15329    let local_var_content = local_var_resp.text().await?;
15330
15331    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15332        serde_json::from_str(&local_var_content).map_err(Error::from)
15333    } else {
15334        let local_var_entity: Option<IpamVlanGroupsAvailableVlansCreateError> =
15335            serde_json::from_str(&local_var_content).ok();
15336        let local_var_error = ResponseContent {
15337            status: local_var_status,
15338            content: local_var_content,
15339            entity: local_var_entity,
15340        };
15341        Err(Error::ResponseError(local_var_error))
15342    }
15343}
15344
15345/// A convenience method for listing available VLAN IDs within a VLANGroup. By default, the number of VIDs returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.
15346pub async fn ipam_vlan_groups_available_vlans_list(
15347    configuration: &configuration::Configuration,
15348    id: &str,
15349    format: Option<&str>,
15350    limit: Option<i32>,
15351    offset: Option<i32>,
15352    sort: Option<&str>,
15353    depth: Option<i32>,
15354    exclude_m2m: Option<bool>,
15355) -> Result<
15356    crate::models::IpamVlanGroupsAvailableVlansList200Response,
15357    Error<IpamVlanGroupsAvailableVlansListError>,
15358> {
15359    let local_var_configuration = configuration;
15360
15361    let local_var_client = &local_var_configuration.client;
15362
15363    let local_var_uri_str = format!(
15364        "{}/ipam/vlan-groups/{id}/available-vlans/",
15365        local_var_configuration.base_path,
15366        id = crate::apis::urlencode(id)
15367    );
15368    let mut local_var_req_builder =
15369        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15370
15371    if let Some(ref local_var_str) = format {
15372        local_var_req_builder =
15373            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15374    }
15375    if let Some(ref local_var_str) = limit {
15376        local_var_req_builder =
15377            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15378    }
15379    if let Some(ref local_var_str) = offset {
15380        local_var_req_builder =
15381            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
15382    }
15383    if let Some(ref local_var_str) = sort {
15384        local_var_req_builder =
15385            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
15386    }
15387    if let Some(ref local_var_str) = depth {
15388        local_var_req_builder =
15389            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
15390    }
15391    if let Some(ref local_var_str) = exclude_m2m {
15392        local_var_req_builder =
15393            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
15394    }
15395    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15396        local_var_req_builder =
15397            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15398    }
15399    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15400        let local_var_key = local_var_apikey.key.clone();
15401        let local_var_value = match local_var_apikey.prefix {
15402            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15403            None => local_var_key,
15404        };
15405        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15406    };
15407
15408    let local_var_req = local_var_req_builder.build()?;
15409    let local_var_resp = local_var_client.execute(local_var_req).await?;
15410
15411    let local_var_status = local_var_resp.status();
15412    let local_var_content = local_var_resp.text().await?;
15413
15414    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15415        serde_json::from_str(&local_var_content).map_err(Error::from)
15416    } else {
15417        let local_var_entity: Option<IpamVlanGroupsAvailableVlansListError> =
15418            serde_json::from_str(&local_var_content).ok();
15419        let local_var_error = ResponseContent {
15420            status: local_var_status,
15421            content: local_var_content,
15422            entity: local_var_entity,
15423        };
15424        Err(Error::ResponseError(local_var_error))
15425    }
15426}
15427
15428/// Destroy a list of VLAN group objects.
15429pub async fn ipam_vlan_groups_bulk_destroy(
15430    configuration: &configuration::Configuration,
15431    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
15432    format: Option<&str>,
15433) -> Result<(), Error<IpamVlanGroupsBulkDestroyError>> {
15434    let local_var_configuration = configuration;
15435
15436    let local_var_client = &local_var_configuration.client;
15437
15438    let local_var_uri_str = format!("{}/ipam/vlan-groups/", local_var_configuration.base_path);
15439    let mut local_var_req_builder =
15440        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15441
15442    if let Some(ref local_var_str) = format {
15443        local_var_req_builder =
15444            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15445    }
15446    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15447        local_var_req_builder =
15448            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15449    }
15450    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15451        let local_var_key = local_var_apikey.key.clone();
15452        let local_var_value = match local_var_apikey.prefix {
15453            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15454            None => local_var_key,
15455        };
15456        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15457    };
15458    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
15459
15460    let local_var_req = local_var_req_builder.build()?;
15461    let local_var_resp = local_var_client.execute(local_var_req).await?;
15462
15463    let local_var_status = local_var_resp.status();
15464    let local_var_content = local_var_resp.text().await?;
15465
15466    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15467        Ok(())
15468    } else {
15469        let local_var_entity: Option<IpamVlanGroupsBulkDestroyError> =
15470            serde_json::from_str(&local_var_content).ok();
15471        let local_var_error = ResponseContent {
15472            status: local_var_status,
15473            content: local_var_content,
15474            entity: local_var_entity,
15475        };
15476        Err(Error::ResponseError(local_var_error))
15477    }
15478}
15479
15480/// Partial update a list of VLAN group objects.
15481pub async fn ipam_vlan_groups_bulk_partial_update(
15482    configuration: &configuration::Configuration,
15483    patched_bulk_writable_vlan_group_request: Vec<
15484        crate::models::PatchedBulkWritableVlanGroupRequest,
15485    >,
15486    format: Option<&str>,
15487) -> Result<Vec<crate::models::VlanGroup>, Error<IpamVlanGroupsBulkPartialUpdateError>> {
15488    let local_var_configuration = configuration;
15489
15490    let local_var_client = &local_var_configuration.client;
15491
15492    let local_var_uri_str = format!("{}/ipam/vlan-groups/", local_var_configuration.base_path);
15493    let mut local_var_req_builder =
15494        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15495
15496    if let Some(ref local_var_str) = format {
15497        local_var_req_builder =
15498            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15499    }
15500    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15501        local_var_req_builder =
15502            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15503    }
15504    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15505        let local_var_key = local_var_apikey.key.clone();
15506        let local_var_value = match local_var_apikey.prefix {
15507            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15508            None => local_var_key,
15509        };
15510        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15511    };
15512    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vlan_group_request);
15513
15514    let local_var_req = local_var_req_builder.build()?;
15515    let local_var_resp = local_var_client.execute(local_var_req).await?;
15516
15517    let local_var_status = local_var_resp.status();
15518    let local_var_content = local_var_resp.text().await?;
15519
15520    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15521        serde_json::from_str(&local_var_content).map_err(Error::from)
15522    } else {
15523        let local_var_entity: Option<IpamVlanGroupsBulkPartialUpdateError> =
15524            serde_json::from_str(&local_var_content).ok();
15525        let local_var_error = ResponseContent {
15526            status: local_var_status,
15527            content: local_var_content,
15528            entity: local_var_entity,
15529        };
15530        Err(Error::ResponseError(local_var_error))
15531    }
15532}
15533
15534/// Update a list of VLAN group objects.
15535pub async fn ipam_vlan_groups_bulk_update(
15536    configuration: &configuration::Configuration,
15537    bulk_writable_vlan_group_request: Vec<crate::models::BulkWritableVlanGroupRequest>,
15538    format: Option<&str>,
15539) -> Result<Vec<crate::models::VlanGroup>, Error<IpamVlanGroupsBulkUpdateError>> {
15540    let local_var_configuration = configuration;
15541
15542    let local_var_client = &local_var_configuration.client;
15543
15544    let local_var_uri_str = format!("{}/ipam/vlan-groups/", local_var_configuration.base_path);
15545    let mut local_var_req_builder =
15546        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15547
15548    if let Some(ref local_var_str) = format {
15549        local_var_req_builder =
15550            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15551    }
15552    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15553        local_var_req_builder =
15554            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15555    }
15556    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15557        let local_var_key = local_var_apikey.key.clone();
15558        let local_var_value = match local_var_apikey.prefix {
15559            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15560            None => local_var_key,
15561        };
15562        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15563    };
15564    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vlan_group_request);
15565
15566    let local_var_req = local_var_req_builder.build()?;
15567    let local_var_resp = local_var_client.execute(local_var_req).await?;
15568
15569    let local_var_status = local_var_resp.status();
15570    let local_var_content = local_var_resp.text().await?;
15571
15572    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15573        serde_json::from_str(&local_var_content).map_err(Error::from)
15574    } else {
15575        let local_var_entity: Option<IpamVlanGroupsBulkUpdateError> =
15576            serde_json::from_str(&local_var_content).ok();
15577        let local_var_error = ResponseContent {
15578            status: local_var_status,
15579            content: local_var_content,
15580            entity: local_var_entity,
15581        };
15582        Err(Error::ResponseError(local_var_error))
15583    }
15584}
15585
15586/// Create one or more VLAN group objects.
15587pub async fn ipam_vlan_groups_create(
15588    configuration: &configuration::Configuration,
15589    vlan_group_request: crate::models::VlanGroupRequest,
15590    format: Option<&str>,
15591) -> Result<crate::models::VlanGroup, Error<IpamVlanGroupsCreateError>> {
15592    let local_var_configuration = configuration;
15593
15594    let local_var_client = &local_var_configuration.client;
15595
15596    let local_var_uri_str = format!("{}/ipam/vlan-groups/", local_var_configuration.base_path);
15597    let mut local_var_req_builder =
15598        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15599
15600    if let Some(ref local_var_str) = format {
15601        local_var_req_builder =
15602            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15603    }
15604    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15605        local_var_req_builder =
15606            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15607    }
15608    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15609        let local_var_key = local_var_apikey.key.clone();
15610        let local_var_value = match local_var_apikey.prefix {
15611            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15612            None => local_var_key,
15613        };
15614        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15615    };
15616    local_var_req_builder = local_var_req_builder.json(&vlan_group_request);
15617
15618    let local_var_req = local_var_req_builder.build()?;
15619    let local_var_resp = local_var_client.execute(local_var_req).await?;
15620
15621    let local_var_status = local_var_resp.status();
15622    let local_var_content = local_var_resp.text().await?;
15623
15624    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15625        serde_json::from_str(&local_var_content).map_err(Error::from)
15626    } else {
15627        let local_var_entity: Option<IpamVlanGroupsCreateError> =
15628            serde_json::from_str(&local_var_content).ok();
15629        let local_var_error = ResponseContent {
15630            status: local_var_status,
15631            content: local_var_content,
15632            entity: local_var_entity,
15633        };
15634        Err(Error::ResponseError(local_var_error))
15635    }
15636}
15637
15638/// Destroy a VLAN group object.
15639pub async fn ipam_vlan_groups_destroy(
15640    configuration: &configuration::Configuration,
15641    id: &str,
15642    format: Option<&str>,
15643) -> Result<(), Error<IpamVlanGroupsDestroyError>> {
15644    let local_var_configuration = configuration;
15645
15646    let local_var_client = &local_var_configuration.client;
15647
15648    let local_var_uri_str = format!(
15649        "{}/ipam/vlan-groups/{id}/",
15650        local_var_configuration.base_path,
15651        id = crate::apis::urlencode(id)
15652    );
15653    let mut local_var_req_builder =
15654        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15655
15656    if let Some(ref local_var_str) = format {
15657        local_var_req_builder =
15658            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15659    }
15660    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15661        local_var_req_builder =
15662            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15663    }
15664    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15665        let local_var_key = local_var_apikey.key.clone();
15666        let local_var_value = match local_var_apikey.prefix {
15667            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15668            None => local_var_key,
15669        };
15670        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15671    };
15672
15673    let local_var_req = local_var_req_builder.build()?;
15674    let local_var_resp = local_var_client.execute(local_var_req).await?;
15675
15676    let local_var_status = local_var_resp.status();
15677    let local_var_content = local_var_resp.text().await?;
15678
15679    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15680        Ok(())
15681    } else {
15682        let local_var_entity: Option<IpamVlanGroupsDestroyError> =
15683            serde_json::from_str(&local_var_content).ok();
15684        let local_var_error = ResponseContent {
15685            status: local_var_status,
15686            content: local_var_content,
15687            entity: local_var_entity,
15688        };
15689        Err(Error::ResponseError(local_var_error))
15690    }
15691}
15692
15693/// Retrieve a list of VLAN group objects.
15694pub async fn ipam_vlan_groups_list(
15695    configuration: &configuration::Configuration,
15696    contacts: Option<Vec<String>>,
15697    contacts__isnull: Option<bool>,
15698    contacts__n: Option<Vec<String>>,
15699    created: Option<Vec<String>>,
15700    created__gt: Option<Vec<String>>,
15701    created__gte: Option<Vec<String>>,
15702    created__isnull: Option<bool>,
15703    created__lt: Option<Vec<String>>,
15704    created__lte: Option<Vec<String>>,
15705    created__n: Option<Vec<String>>,
15706    description: Option<Vec<String>>,
15707    description__ic: Option<Vec<String>>,
15708    description__ie: Option<Vec<String>>,
15709    description__iew: Option<Vec<String>>,
15710    description__ire: Option<Vec<String>>,
15711    description__isw: Option<Vec<String>>,
15712    description__n: Option<Vec<String>>,
15713    description__nic: Option<Vec<String>>,
15714    description__nie: Option<Vec<String>>,
15715    description__niew: Option<Vec<String>>,
15716    description__nire: Option<Vec<String>>,
15717    description__nisw: Option<Vec<String>>,
15718    description__nre: Option<Vec<String>>,
15719    description__re: Option<Vec<String>>,
15720    dynamic_groups: Option<Vec<String>>,
15721    dynamic_groups__n: Option<Vec<String>>,
15722    format: Option<&str>,
15723    id: Option<Vec<uuid::Uuid>>,
15724    id__n: Option<Vec<uuid::Uuid>>,
15725    last_updated: Option<Vec<String>>,
15726    last_updated__gt: Option<Vec<String>>,
15727    last_updated__gte: Option<Vec<String>>,
15728    last_updated__isnull: Option<bool>,
15729    last_updated__lt: Option<Vec<String>>,
15730    last_updated__lte: Option<Vec<String>>,
15731    last_updated__n: Option<Vec<String>>,
15732    limit: Option<i32>,
15733    location: Option<Vec<String>>,
15734    location__isnull: Option<bool>,
15735    location__n: Option<Vec<String>>,
15736    name: Option<Vec<String>>,
15737    name__ic: Option<Vec<String>>,
15738    name__ie: Option<Vec<String>>,
15739    name__iew: Option<Vec<String>>,
15740    name__ire: Option<Vec<String>>,
15741    name__isw: Option<Vec<String>>,
15742    name__n: Option<Vec<String>>,
15743    name__nic: Option<Vec<String>>,
15744    name__nie: Option<Vec<String>>,
15745    name__niew: Option<Vec<String>>,
15746    name__nire: Option<Vec<String>>,
15747    name__nisw: Option<Vec<String>>,
15748    name__nre: Option<Vec<String>>,
15749    name__re: Option<Vec<String>>,
15750    offset: Option<i32>,
15751    q: Option<&str>,
15752    sort: Option<&str>,
15753    tags: Option<Vec<String>>,
15754    tags__isnull: Option<bool>,
15755    tags__n: Option<Vec<String>>,
15756    teams: Option<Vec<String>>,
15757    teams__isnull: Option<bool>,
15758    teams__n: Option<Vec<String>>,
15759    depth: Option<i32>,
15760    exclude_m2m: Option<bool>,
15761) -> Result<crate::models::PaginatedVlanGroupList, Error<IpamVlanGroupsListError>> {
15762    let local_var_configuration = configuration;
15763
15764    let local_var_client = &local_var_configuration.client;
15765
15766    let local_var_uri_str = format!("{}/ipam/vlan-groups/", local_var_configuration.base_path);
15767    let mut local_var_req_builder =
15768        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15769
15770    if let Some(ref local_var_str) = contacts {
15771        local_var_req_builder = match "multi" {
15772            "multi" => local_var_req_builder.query(
15773                &local_var_str
15774                    .into_iter()
15775                    .map(|p| ("contacts".to_owned(), p.to_string()))
15776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15777            ),
15778            _ => local_var_req_builder.query(&[(
15779                "contacts",
15780                &local_var_str
15781                    .into_iter()
15782                    .map(|p| p.to_string())
15783                    .collect::<Vec<String>>()
15784                    .join(",")
15785                    .to_string(),
15786            )]),
15787        };
15788    }
15789    if let Some(ref local_var_str) = contacts__isnull {
15790        local_var_req_builder =
15791            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
15792    }
15793    if let Some(ref local_var_str) = contacts__n {
15794        local_var_req_builder = match "multi" {
15795            "multi" => local_var_req_builder.query(
15796                &local_var_str
15797                    .into_iter()
15798                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
15799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15800            ),
15801            _ => local_var_req_builder.query(&[(
15802                "contacts__n",
15803                &local_var_str
15804                    .into_iter()
15805                    .map(|p| p.to_string())
15806                    .collect::<Vec<String>>()
15807                    .join(",")
15808                    .to_string(),
15809            )]),
15810        };
15811    }
15812    if let Some(ref local_var_str) = created {
15813        local_var_req_builder = match "multi" {
15814            "multi" => local_var_req_builder.query(
15815                &local_var_str
15816                    .into_iter()
15817                    .map(|p| ("created".to_owned(), p.to_string()))
15818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15819            ),
15820            _ => local_var_req_builder.query(&[(
15821                "created",
15822                &local_var_str
15823                    .into_iter()
15824                    .map(|p| p.to_string())
15825                    .collect::<Vec<String>>()
15826                    .join(",")
15827                    .to_string(),
15828            )]),
15829        };
15830    }
15831    if let Some(ref local_var_str) = created__gt {
15832        local_var_req_builder = match "multi" {
15833            "multi" => local_var_req_builder.query(
15834                &local_var_str
15835                    .into_iter()
15836                    .map(|p| ("created__gt".to_owned(), p.to_string()))
15837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15838            ),
15839            _ => local_var_req_builder.query(&[(
15840                "created__gt",
15841                &local_var_str
15842                    .into_iter()
15843                    .map(|p| p.to_string())
15844                    .collect::<Vec<String>>()
15845                    .join(",")
15846                    .to_string(),
15847            )]),
15848        };
15849    }
15850    if let Some(ref local_var_str) = created__gte {
15851        local_var_req_builder = match "multi" {
15852            "multi" => local_var_req_builder.query(
15853                &local_var_str
15854                    .into_iter()
15855                    .map(|p| ("created__gte".to_owned(), p.to_string()))
15856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15857            ),
15858            _ => local_var_req_builder.query(&[(
15859                "created__gte",
15860                &local_var_str
15861                    .into_iter()
15862                    .map(|p| p.to_string())
15863                    .collect::<Vec<String>>()
15864                    .join(",")
15865                    .to_string(),
15866            )]),
15867        };
15868    }
15869    if let Some(ref local_var_str) = created__isnull {
15870        local_var_req_builder =
15871            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
15872    }
15873    if let Some(ref local_var_str) = created__lt {
15874        local_var_req_builder = match "multi" {
15875            "multi" => local_var_req_builder.query(
15876                &local_var_str
15877                    .into_iter()
15878                    .map(|p| ("created__lt".to_owned(), p.to_string()))
15879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15880            ),
15881            _ => local_var_req_builder.query(&[(
15882                "created__lt",
15883                &local_var_str
15884                    .into_iter()
15885                    .map(|p| p.to_string())
15886                    .collect::<Vec<String>>()
15887                    .join(",")
15888                    .to_string(),
15889            )]),
15890        };
15891    }
15892    if let Some(ref local_var_str) = created__lte {
15893        local_var_req_builder = match "multi" {
15894            "multi" => local_var_req_builder.query(
15895                &local_var_str
15896                    .into_iter()
15897                    .map(|p| ("created__lte".to_owned(), p.to_string()))
15898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15899            ),
15900            _ => local_var_req_builder.query(&[(
15901                "created__lte",
15902                &local_var_str
15903                    .into_iter()
15904                    .map(|p| p.to_string())
15905                    .collect::<Vec<String>>()
15906                    .join(",")
15907                    .to_string(),
15908            )]),
15909        };
15910    }
15911    if let Some(ref local_var_str) = created__n {
15912        local_var_req_builder = match "multi" {
15913            "multi" => local_var_req_builder.query(
15914                &local_var_str
15915                    .into_iter()
15916                    .map(|p| ("created__n".to_owned(), p.to_string()))
15917                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15918            ),
15919            _ => local_var_req_builder.query(&[(
15920                "created__n",
15921                &local_var_str
15922                    .into_iter()
15923                    .map(|p| p.to_string())
15924                    .collect::<Vec<String>>()
15925                    .join(",")
15926                    .to_string(),
15927            )]),
15928        };
15929    }
15930    if let Some(ref local_var_str) = description {
15931        local_var_req_builder = match "multi" {
15932            "multi" => local_var_req_builder.query(
15933                &local_var_str
15934                    .into_iter()
15935                    .map(|p| ("description".to_owned(), p.to_string()))
15936                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15937            ),
15938            _ => local_var_req_builder.query(&[(
15939                "description",
15940                &local_var_str
15941                    .into_iter()
15942                    .map(|p| p.to_string())
15943                    .collect::<Vec<String>>()
15944                    .join(",")
15945                    .to_string(),
15946            )]),
15947        };
15948    }
15949    if let Some(ref local_var_str) = description__ic {
15950        local_var_req_builder = match "multi" {
15951            "multi" => local_var_req_builder.query(
15952                &local_var_str
15953                    .into_iter()
15954                    .map(|p| ("description__ic".to_owned(), p.to_string()))
15955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15956            ),
15957            _ => local_var_req_builder.query(&[(
15958                "description__ic",
15959                &local_var_str
15960                    .into_iter()
15961                    .map(|p| p.to_string())
15962                    .collect::<Vec<String>>()
15963                    .join(",")
15964                    .to_string(),
15965            )]),
15966        };
15967    }
15968    if let Some(ref local_var_str) = description__ie {
15969        local_var_req_builder = match "multi" {
15970            "multi" => local_var_req_builder.query(
15971                &local_var_str
15972                    .into_iter()
15973                    .map(|p| ("description__ie".to_owned(), p.to_string()))
15974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15975            ),
15976            _ => local_var_req_builder.query(&[(
15977                "description__ie",
15978                &local_var_str
15979                    .into_iter()
15980                    .map(|p| p.to_string())
15981                    .collect::<Vec<String>>()
15982                    .join(",")
15983                    .to_string(),
15984            )]),
15985        };
15986    }
15987    if let Some(ref local_var_str) = description__iew {
15988        local_var_req_builder = match "multi" {
15989            "multi" => local_var_req_builder.query(
15990                &local_var_str
15991                    .into_iter()
15992                    .map(|p| ("description__iew".to_owned(), p.to_string()))
15993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15994            ),
15995            _ => local_var_req_builder.query(&[(
15996                "description__iew",
15997                &local_var_str
15998                    .into_iter()
15999                    .map(|p| p.to_string())
16000                    .collect::<Vec<String>>()
16001                    .join(",")
16002                    .to_string(),
16003            )]),
16004        };
16005    }
16006    if let Some(ref local_var_str) = description__ire {
16007        local_var_req_builder = match "multi" {
16008            "multi" => local_var_req_builder.query(
16009                &local_var_str
16010                    .into_iter()
16011                    .map(|p| ("description__ire".to_owned(), p.to_string()))
16012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16013            ),
16014            _ => local_var_req_builder.query(&[(
16015                "description__ire",
16016                &local_var_str
16017                    .into_iter()
16018                    .map(|p| p.to_string())
16019                    .collect::<Vec<String>>()
16020                    .join(",")
16021                    .to_string(),
16022            )]),
16023        };
16024    }
16025    if let Some(ref local_var_str) = description__isw {
16026        local_var_req_builder = match "multi" {
16027            "multi" => local_var_req_builder.query(
16028                &local_var_str
16029                    .into_iter()
16030                    .map(|p| ("description__isw".to_owned(), p.to_string()))
16031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16032            ),
16033            _ => local_var_req_builder.query(&[(
16034                "description__isw",
16035                &local_var_str
16036                    .into_iter()
16037                    .map(|p| p.to_string())
16038                    .collect::<Vec<String>>()
16039                    .join(",")
16040                    .to_string(),
16041            )]),
16042        };
16043    }
16044    if let Some(ref local_var_str) = description__n {
16045        local_var_req_builder = match "multi" {
16046            "multi" => local_var_req_builder.query(
16047                &local_var_str
16048                    .into_iter()
16049                    .map(|p| ("description__n".to_owned(), p.to_string()))
16050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16051            ),
16052            _ => local_var_req_builder.query(&[(
16053                "description__n",
16054                &local_var_str
16055                    .into_iter()
16056                    .map(|p| p.to_string())
16057                    .collect::<Vec<String>>()
16058                    .join(",")
16059                    .to_string(),
16060            )]),
16061        };
16062    }
16063    if let Some(ref local_var_str) = description__nic {
16064        local_var_req_builder = match "multi" {
16065            "multi" => local_var_req_builder.query(
16066                &local_var_str
16067                    .into_iter()
16068                    .map(|p| ("description__nic".to_owned(), p.to_string()))
16069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16070            ),
16071            _ => local_var_req_builder.query(&[(
16072                "description__nic",
16073                &local_var_str
16074                    .into_iter()
16075                    .map(|p| p.to_string())
16076                    .collect::<Vec<String>>()
16077                    .join(",")
16078                    .to_string(),
16079            )]),
16080        };
16081    }
16082    if let Some(ref local_var_str) = description__nie {
16083        local_var_req_builder = match "multi" {
16084            "multi" => local_var_req_builder.query(
16085                &local_var_str
16086                    .into_iter()
16087                    .map(|p| ("description__nie".to_owned(), p.to_string()))
16088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16089            ),
16090            _ => local_var_req_builder.query(&[(
16091                "description__nie",
16092                &local_var_str
16093                    .into_iter()
16094                    .map(|p| p.to_string())
16095                    .collect::<Vec<String>>()
16096                    .join(",")
16097                    .to_string(),
16098            )]),
16099        };
16100    }
16101    if let Some(ref local_var_str) = description__niew {
16102        local_var_req_builder = match "multi" {
16103            "multi" => local_var_req_builder.query(
16104                &local_var_str
16105                    .into_iter()
16106                    .map(|p| ("description__niew".to_owned(), p.to_string()))
16107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16108            ),
16109            _ => local_var_req_builder.query(&[(
16110                "description__niew",
16111                &local_var_str
16112                    .into_iter()
16113                    .map(|p| p.to_string())
16114                    .collect::<Vec<String>>()
16115                    .join(",")
16116                    .to_string(),
16117            )]),
16118        };
16119    }
16120    if let Some(ref local_var_str) = description__nire {
16121        local_var_req_builder = match "multi" {
16122            "multi" => local_var_req_builder.query(
16123                &local_var_str
16124                    .into_iter()
16125                    .map(|p| ("description__nire".to_owned(), p.to_string()))
16126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16127            ),
16128            _ => local_var_req_builder.query(&[(
16129                "description__nire",
16130                &local_var_str
16131                    .into_iter()
16132                    .map(|p| p.to_string())
16133                    .collect::<Vec<String>>()
16134                    .join(",")
16135                    .to_string(),
16136            )]),
16137        };
16138    }
16139    if let Some(ref local_var_str) = description__nisw {
16140        local_var_req_builder = match "multi" {
16141            "multi" => local_var_req_builder.query(
16142                &local_var_str
16143                    .into_iter()
16144                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
16145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16146            ),
16147            _ => local_var_req_builder.query(&[(
16148                "description__nisw",
16149                &local_var_str
16150                    .into_iter()
16151                    .map(|p| p.to_string())
16152                    .collect::<Vec<String>>()
16153                    .join(",")
16154                    .to_string(),
16155            )]),
16156        };
16157    }
16158    if let Some(ref local_var_str) = description__nre {
16159        local_var_req_builder = match "multi" {
16160            "multi" => local_var_req_builder.query(
16161                &local_var_str
16162                    .into_iter()
16163                    .map(|p| ("description__nre".to_owned(), p.to_string()))
16164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16165            ),
16166            _ => local_var_req_builder.query(&[(
16167                "description__nre",
16168                &local_var_str
16169                    .into_iter()
16170                    .map(|p| p.to_string())
16171                    .collect::<Vec<String>>()
16172                    .join(",")
16173                    .to_string(),
16174            )]),
16175        };
16176    }
16177    if let Some(ref local_var_str) = description__re {
16178        local_var_req_builder = match "multi" {
16179            "multi" => local_var_req_builder.query(
16180                &local_var_str
16181                    .into_iter()
16182                    .map(|p| ("description__re".to_owned(), p.to_string()))
16183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16184            ),
16185            _ => local_var_req_builder.query(&[(
16186                "description__re",
16187                &local_var_str
16188                    .into_iter()
16189                    .map(|p| p.to_string())
16190                    .collect::<Vec<String>>()
16191                    .join(",")
16192                    .to_string(),
16193            )]),
16194        };
16195    }
16196    if let Some(ref local_var_str) = dynamic_groups {
16197        local_var_req_builder = match "multi" {
16198            "multi" => local_var_req_builder.query(
16199                &local_var_str
16200                    .into_iter()
16201                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
16202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16203            ),
16204            _ => local_var_req_builder.query(&[(
16205                "dynamic_groups",
16206                &local_var_str
16207                    .into_iter()
16208                    .map(|p| p.to_string())
16209                    .collect::<Vec<String>>()
16210                    .join(",")
16211                    .to_string(),
16212            )]),
16213        };
16214    }
16215    if let Some(ref local_var_str) = dynamic_groups__n {
16216        local_var_req_builder = match "multi" {
16217            "multi" => local_var_req_builder.query(
16218                &local_var_str
16219                    .into_iter()
16220                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
16221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16222            ),
16223            _ => local_var_req_builder.query(&[(
16224                "dynamic_groups__n",
16225                &local_var_str
16226                    .into_iter()
16227                    .map(|p| p.to_string())
16228                    .collect::<Vec<String>>()
16229                    .join(",")
16230                    .to_string(),
16231            )]),
16232        };
16233    }
16234    if let Some(ref local_var_str) = format {
16235        local_var_req_builder =
16236            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
16237    }
16238    if let Some(ref local_var_str) = id {
16239        local_var_req_builder = match "multi" {
16240            "multi" => local_var_req_builder.query(
16241                &local_var_str
16242                    .into_iter()
16243                    .map(|p| ("id".to_owned(), p.to_string()))
16244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16245            ),
16246            _ => local_var_req_builder.query(&[(
16247                "id",
16248                &local_var_str
16249                    .into_iter()
16250                    .map(|p| p.to_string())
16251                    .collect::<Vec<String>>()
16252                    .join(",")
16253                    .to_string(),
16254            )]),
16255        };
16256    }
16257    if let Some(ref local_var_str) = id__n {
16258        local_var_req_builder = match "multi" {
16259            "multi" => local_var_req_builder.query(
16260                &local_var_str
16261                    .into_iter()
16262                    .map(|p| ("id__n".to_owned(), p.to_string()))
16263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16264            ),
16265            _ => local_var_req_builder.query(&[(
16266                "id__n",
16267                &local_var_str
16268                    .into_iter()
16269                    .map(|p| p.to_string())
16270                    .collect::<Vec<String>>()
16271                    .join(",")
16272                    .to_string(),
16273            )]),
16274        };
16275    }
16276    if let Some(ref local_var_str) = last_updated {
16277        local_var_req_builder = match "multi" {
16278            "multi" => local_var_req_builder.query(
16279                &local_var_str
16280                    .into_iter()
16281                    .map(|p| ("last_updated".to_owned(), p.to_string()))
16282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16283            ),
16284            _ => local_var_req_builder.query(&[(
16285                "last_updated",
16286                &local_var_str
16287                    .into_iter()
16288                    .map(|p| p.to_string())
16289                    .collect::<Vec<String>>()
16290                    .join(",")
16291                    .to_string(),
16292            )]),
16293        };
16294    }
16295    if let Some(ref local_var_str) = last_updated__gt {
16296        local_var_req_builder = match "multi" {
16297            "multi" => local_var_req_builder.query(
16298                &local_var_str
16299                    .into_iter()
16300                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
16301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16302            ),
16303            _ => local_var_req_builder.query(&[(
16304                "last_updated__gt",
16305                &local_var_str
16306                    .into_iter()
16307                    .map(|p| p.to_string())
16308                    .collect::<Vec<String>>()
16309                    .join(",")
16310                    .to_string(),
16311            )]),
16312        };
16313    }
16314    if let Some(ref local_var_str) = last_updated__gte {
16315        local_var_req_builder = match "multi" {
16316            "multi" => local_var_req_builder.query(
16317                &local_var_str
16318                    .into_iter()
16319                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
16320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16321            ),
16322            _ => local_var_req_builder.query(&[(
16323                "last_updated__gte",
16324                &local_var_str
16325                    .into_iter()
16326                    .map(|p| p.to_string())
16327                    .collect::<Vec<String>>()
16328                    .join(",")
16329                    .to_string(),
16330            )]),
16331        };
16332    }
16333    if let Some(ref local_var_str) = last_updated__isnull {
16334        local_var_req_builder =
16335            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
16336    }
16337    if let Some(ref local_var_str) = last_updated__lt {
16338        local_var_req_builder = match "multi" {
16339            "multi" => local_var_req_builder.query(
16340                &local_var_str
16341                    .into_iter()
16342                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
16343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16344            ),
16345            _ => local_var_req_builder.query(&[(
16346                "last_updated__lt",
16347                &local_var_str
16348                    .into_iter()
16349                    .map(|p| p.to_string())
16350                    .collect::<Vec<String>>()
16351                    .join(",")
16352                    .to_string(),
16353            )]),
16354        };
16355    }
16356    if let Some(ref local_var_str) = last_updated__lte {
16357        local_var_req_builder = match "multi" {
16358            "multi" => local_var_req_builder.query(
16359                &local_var_str
16360                    .into_iter()
16361                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
16362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16363            ),
16364            _ => local_var_req_builder.query(&[(
16365                "last_updated__lte",
16366                &local_var_str
16367                    .into_iter()
16368                    .map(|p| p.to_string())
16369                    .collect::<Vec<String>>()
16370                    .join(",")
16371                    .to_string(),
16372            )]),
16373        };
16374    }
16375    if let Some(ref local_var_str) = last_updated__n {
16376        local_var_req_builder = match "multi" {
16377            "multi" => local_var_req_builder.query(
16378                &local_var_str
16379                    .into_iter()
16380                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
16381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16382            ),
16383            _ => local_var_req_builder.query(&[(
16384                "last_updated__n",
16385                &local_var_str
16386                    .into_iter()
16387                    .map(|p| p.to_string())
16388                    .collect::<Vec<String>>()
16389                    .join(",")
16390                    .to_string(),
16391            )]),
16392        };
16393    }
16394    if let Some(ref local_var_str) = limit {
16395        local_var_req_builder =
16396            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
16397    }
16398    if let Some(ref local_var_str) = location {
16399        local_var_req_builder = match "multi" {
16400            "multi" => local_var_req_builder.query(
16401                &local_var_str
16402                    .into_iter()
16403                    .map(|p| ("location".to_owned(), p.to_string()))
16404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16405            ),
16406            _ => local_var_req_builder.query(&[(
16407                "location",
16408                &local_var_str
16409                    .into_iter()
16410                    .map(|p| p.to_string())
16411                    .collect::<Vec<String>>()
16412                    .join(",")
16413                    .to_string(),
16414            )]),
16415        };
16416    }
16417    if let Some(ref local_var_str) = location__isnull {
16418        local_var_req_builder =
16419            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
16420    }
16421    if let Some(ref local_var_str) = location__n {
16422        local_var_req_builder = match "multi" {
16423            "multi" => local_var_req_builder.query(
16424                &local_var_str
16425                    .into_iter()
16426                    .map(|p| ("location__n".to_owned(), p.to_string()))
16427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16428            ),
16429            _ => local_var_req_builder.query(&[(
16430                "location__n",
16431                &local_var_str
16432                    .into_iter()
16433                    .map(|p| p.to_string())
16434                    .collect::<Vec<String>>()
16435                    .join(",")
16436                    .to_string(),
16437            )]),
16438        };
16439    }
16440    if let Some(ref local_var_str) = name {
16441        local_var_req_builder = match "multi" {
16442            "multi" => local_var_req_builder.query(
16443                &local_var_str
16444                    .into_iter()
16445                    .map(|p| ("name".to_owned(), p.to_string()))
16446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16447            ),
16448            _ => local_var_req_builder.query(&[(
16449                "name",
16450                &local_var_str
16451                    .into_iter()
16452                    .map(|p| p.to_string())
16453                    .collect::<Vec<String>>()
16454                    .join(",")
16455                    .to_string(),
16456            )]),
16457        };
16458    }
16459    if let Some(ref local_var_str) = name__ic {
16460        local_var_req_builder = match "multi" {
16461            "multi" => local_var_req_builder.query(
16462                &local_var_str
16463                    .into_iter()
16464                    .map(|p| ("name__ic".to_owned(), p.to_string()))
16465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16466            ),
16467            _ => local_var_req_builder.query(&[(
16468                "name__ic",
16469                &local_var_str
16470                    .into_iter()
16471                    .map(|p| p.to_string())
16472                    .collect::<Vec<String>>()
16473                    .join(",")
16474                    .to_string(),
16475            )]),
16476        };
16477    }
16478    if let Some(ref local_var_str) = name__ie {
16479        local_var_req_builder = match "multi" {
16480            "multi" => local_var_req_builder.query(
16481                &local_var_str
16482                    .into_iter()
16483                    .map(|p| ("name__ie".to_owned(), p.to_string()))
16484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16485            ),
16486            _ => local_var_req_builder.query(&[(
16487                "name__ie",
16488                &local_var_str
16489                    .into_iter()
16490                    .map(|p| p.to_string())
16491                    .collect::<Vec<String>>()
16492                    .join(",")
16493                    .to_string(),
16494            )]),
16495        };
16496    }
16497    if let Some(ref local_var_str) = name__iew {
16498        local_var_req_builder = match "multi" {
16499            "multi" => local_var_req_builder.query(
16500                &local_var_str
16501                    .into_iter()
16502                    .map(|p| ("name__iew".to_owned(), p.to_string()))
16503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16504            ),
16505            _ => local_var_req_builder.query(&[(
16506                "name__iew",
16507                &local_var_str
16508                    .into_iter()
16509                    .map(|p| p.to_string())
16510                    .collect::<Vec<String>>()
16511                    .join(",")
16512                    .to_string(),
16513            )]),
16514        };
16515    }
16516    if let Some(ref local_var_str) = name__ire {
16517        local_var_req_builder = match "multi" {
16518            "multi" => local_var_req_builder.query(
16519                &local_var_str
16520                    .into_iter()
16521                    .map(|p| ("name__ire".to_owned(), p.to_string()))
16522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16523            ),
16524            _ => local_var_req_builder.query(&[(
16525                "name__ire",
16526                &local_var_str
16527                    .into_iter()
16528                    .map(|p| p.to_string())
16529                    .collect::<Vec<String>>()
16530                    .join(",")
16531                    .to_string(),
16532            )]),
16533        };
16534    }
16535    if let Some(ref local_var_str) = name__isw {
16536        local_var_req_builder = match "multi" {
16537            "multi" => local_var_req_builder.query(
16538                &local_var_str
16539                    .into_iter()
16540                    .map(|p| ("name__isw".to_owned(), p.to_string()))
16541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16542            ),
16543            _ => local_var_req_builder.query(&[(
16544                "name__isw",
16545                &local_var_str
16546                    .into_iter()
16547                    .map(|p| p.to_string())
16548                    .collect::<Vec<String>>()
16549                    .join(",")
16550                    .to_string(),
16551            )]),
16552        };
16553    }
16554    if let Some(ref local_var_str) = name__n {
16555        local_var_req_builder = match "multi" {
16556            "multi" => local_var_req_builder.query(
16557                &local_var_str
16558                    .into_iter()
16559                    .map(|p| ("name__n".to_owned(), p.to_string()))
16560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16561            ),
16562            _ => local_var_req_builder.query(&[(
16563                "name__n",
16564                &local_var_str
16565                    .into_iter()
16566                    .map(|p| p.to_string())
16567                    .collect::<Vec<String>>()
16568                    .join(",")
16569                    .to_string(),
16570            )]),
16571        };
16572    }
16573    if let Some(ref local_var_str) = name__nic {
16574        local_var_req_builder = match "multi" {
16575            "multi" => local_var_req_builder.query(
16576                &local_var_str
16577                    .into_iter()
16578                    .map(|p| ("name__nic".to_owned(), p.to_string()))
16579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16580            ),
16581            _ => local_var_req_builder.query(&[(
16582                "name__nic",
16583                &local_var_str
16584                    .into_iter()
16585                    .map(|p| p.to_string())
16586                    .collect::<Vec<String>>()
16587                    .join(",")
16588                    .to_string(),
16589            )]),
16590        };
16591    }
16592    if let Some(ref local_var_str) = name__nie {
16593        local_var_req_builder = match "multi" {
16594            "multi" => local_var_req_builder.query(
16595                &local_var_str
16596                    .into_iter()
16597                    .map(|p| ("name__nie".to_owned(), p.to_string()))
16598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16599            ),
16600            _ => local_var_req_builder.query(&[(
16601                "name__nie",
16602                &local_var_str
16603                    .into_iter()
16604                    .map(|p| p.to_string())
16605                    .collect::<Vec<String>>()
16606                    .join(",")
16607                    .to_string(),
16608            )]),
16609        };
16610    }
16611    if let Some(ref local_var_str) = name__niew {
16612        local_var_req_builder = match "multi" {
16613            "multi" => local_var_req_builder.query(
16614                &local_var_str
16615                    .into_iter()
16616                    .map(|p| ("name__niew".to_owned(), p.to_string()))
16617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16618            ),
16619            _ => local_var_req_builder.query(&[(
16620                "name__niew",
16621                &local_var_str
16622                    .into_iter()
16623                    .map(|p| p.to_string())
16624                    .collect::<Vec<String>>()
16625                    .join(",")
16626                    .to_string(),
16627            )]),
16628        };
16629    }
16630    if let Some(ref local_var_str) = name__nire {
16631        local_var_req_builder = match "multi" {
16632            "multi" => local_var_req_builder.query(
16633                &local_var_str
16634                    .into_iter()
16635                    .map(|p| ("name__nire".to_owned(), p.to_string()))
16636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16637            ),
16638            _ => local_var_req_builder.query(&[(
16639                "name__nire",
16640                &local_var_str
16641                    .into_iter()
16642                    .map(|p| p.to_string())
16643                    .collect::<Vec<String>>()
16644                    .join(",")
16645                    .to_string(),
16646            )]),
16647        };
16648    }
16649    if let Some(ref local_var_str) = name__nisw {
16650        local_var_req_builder = match "multi" {
16651            "multi" => local_var_req_builder.query(
16652                &local_var_str
16653                    .into_iter()
16654                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
16655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16656            ),
16657            _ => local_var_req_builder.query(&[(
16658                "name__nisw",
16659                &local_var_str
16660                    .into_iter()
16661                    .map(|p| p.to_string())
16662                    .collect::<Vec<String>>()
16663                    .join(",")
16664                    .to_string(),
16665            )]),
16666        };
16667    }
16668    if let Some(ref local_var_str) = name__nre {
16669        local_var_req_builder = match "multi" {
16670            "multi" => local_var_req_builder.query(
16671                &local_var_str
16672                    .into_iter()
16673                    .map(|p| ("name__nre".to_owned(), p.to_string()))
16674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16675            ),
16676            _ => local_var_req_builder.query(&[(
16677                "name__nre",
16678                &local_var_str
16679                    .into_iter()
16680                    .map(|p| p.to_string())
16681                    .collect::<Vec<String>>()
16682                    .join(",")
16683                    .to_string(),
16684            )]),
16685        };
16686    }
16687    if let Some(ref local_var_str) = name__re {
16688        local_var_req_builder = match "multi" {
16689            "multi" => local_var_req_builder.query(
16690                &local_var_str
16691                    .into_iter()
16692                    .map(|p| ("name__re".to_owned(), p.to_string()))
16693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16694            ),
16695            _ => local_var_req_builder.query(&[(
16696                "name__re",
16697                &local_var_str
16698                    .into_iter()
16699                    .map(|p| p.to_string())
16700                    .collect::<Vec<String>>()
16701                    .join(",")
16702                    .to_string(),
16703            )]),
16704        };
16705    }
16706    if let Some(ref local_var_str) = offset {
16707        local_var_req_builder =
16708            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
16709    }
16710    if let Some(ref local_var_str) = q {
16711        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
16712    }
16713    if let Some(ref local_var_str) = sort {
16714        local_var_req_builder =
16715            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
16716    }
16717    if let Some(ref local_var_str) = tags {
16718        local_var_req_builder = match "multi" {
16719            "multi" => local_var_req_builder.query(
16720                &local_var_str
16721                    .into_iter()
16722                    .map(|p| ("tags".to_owned(), p.to_string()))
16723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16724            ),
16725            _ => local_var_req_builder.query(&[(
16726                "tags",
16727                &local_var_str
16728                    .into_iter()
16729                    .map(|p| p.to_string())
16730                    .collect::<Vec<String>>()
16731                    .join(",")
16732                    .to_string(),
16733            )]),
16734        };
16735    }
16736    if let Some(ref local_var_str) = tags__isnull {
16737        local_var_req_builder =
16738            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
16739    }
16740    if let Some(ref local_var_str) = tags__n {
16741        local_var_req_builder = match "multi" {
16742            "multi" => local_var_req_builder.query(
16743                &local_var_str
16744                    .into_iter()
16745                    .map(|p| ("tags__n".to_owned(), p.to_string()))
16746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16747            ),
16748            _ => local_var_req_builder.query(&[(
16749                "tags__n",
16750                &local_var_str
16751                    .into_iter()
16752                    .map(|p| p.to_string())
16753                    .collect::<Vec<String>>()
16754                    .join(",")
16755                    .to_string(),
16756            )]),
16757        };
16758    }
16759    if let Some(ref local_var_str) = teams {
16760        local_var_req_builder = match "multi" {
16761            "multi" => local_var_req_builder.query(
16762                &local_var_str
16763                    .into_iter()
16764                    .map(|p| ("teams".to_owned(), p.to_string()))
16765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16766            ),
16767            _ => local_var_req_builder.query(&[(
16768                "teams",
16769                &local_var_str
16770                    .into_iter()
16771                    .map(|p| p.to_string())
16772                    .collect::<Vec<String>>()
16773                    .join(",")
16774                    .to_string(),
16775            )]),
16776        };
16777    }
16778    if let Some(ref local_var_str) = teams__isnull {
16779        local_var_req_builder =
16780            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
16781    }
16782    if let Some(ref local_var_str) = teams__n {
16783        local_var_req_builder = match "multi" {
16784            "multi" => local_var_req_builder.query(
16785                &local_var_str
16786                    .into_iter()
16787                    .map(|p| ("teams__n".to_owned(), p.to_string()))
16788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16789            ),
16790            _ => local_var_req_builder.query(&[(
16791                "teams__n",
16792                &local_var_str
16793                    .into_iter()
16794                    .map(|p| p.to_string())
16795                    .collect::<Vec<String>>()
16796                    .join(",")
16797                    .to_string(),
16798            )]),
16799        };
16800    }
16801    if let Some(ref local_var_str) = depth {
16802        local_var_req_builder =
16803            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
16804    }
16805    if let Some(ref local_var_str) = exclude_m2m {
16806        local_var_req_builder =
16807            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
16808    }
16809    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16810        local_var_req_builder =
16811            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16812    }
16813    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16814        let local_var_key = local_var_apikey.key.clone();
16815        let local_var_value = match local_var_apikey.prefix {
16816            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16817            None => local_var_key,
16818        };
16819        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16820    };
16821
16822    let local_var_req = local_var_req_builder.build()?;
16823    let local_var_resp = local_var_client.execute(local_var_req).await?;
16824
16825    let local_var_status = local_var_resp.status();
16826    let local_var_content = local_var_resp.text().await?;
16827
16828    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16829        serde_json::from_str(&local_var_content).map_err(Error::from)
16830    } else {
16831        let local_var_entity: Option<IpamVlanGroupsListError> =
16832            serde_json::from_str(&local_var_content).ok();
16833        let local_var_error = ResponseContent {
16834            status: local_var_status,
16835            content: local_var_content,
16836            entity: local_var_entity,
16837        };
16838        Err(Error::ResponseError(local_var_error))
16839    }
16840}
16841
16842/// API methods for returning or creating notes on an object.
16843pub async fn ipam_vlan_groups_notes_create(
16844    configuration: &configuration::Configuration,
16845    id: &str,
16846    note_input_request: crate::models::NoteInputRequest,
16847    format: Option<&str>,
16848) -> Result<crate::models::Note, Error<IpamVlanGroupsNotesCreateError>> {
16849    let local_var_configuration = configuration;
16850
16851    let local_var_client = &local_var_configuration.client;
16852
16853    let local_var_uri_str = format!(
16854        "{}/ipam/vlan-groups/{id}/notes/",
16855        local_var_configuration.base_path,
16856        id = crate::apis::urlencode(id)
16857    );
16858    let mut local_var_req_builder =
16859        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
16860
16861    if let Some(ref local_var_str) = format {
16862        local_var_req_builder =
16863            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
16864    }
16865    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16866        local_var_req_builder =
16867            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16868    }
16869    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16870        let local_var_key = local_var_apikey.key.clone();
16871        let local_var_value = match local_var_apikey.prefix {
16872            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16873            None => local_var_key,
16874        };
16875        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16876    };
16877    local_var_req_builder = local_var_req_builder.json(&note_input_request);
16878
16879    let local_var_req = local_var_req_builder.build()?;
16880    let local_var_resp = local_var_client.execute(local_var_req).await?;
16881
16882    let local_var_status = local_var_resp.status();
16883    let local_var_content = local_var_resp.text().await?;
16884
16885    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16886        serde_json::from_str(&local_var_content).map_err(Error::from)
16887    } else {
16888        let local_var_entity: Option<IpamVlanGroupsNotesCreateError> =
16889            serde_json::from_str(&local_var_content).ok();
16890        let local_var_error = ResponseContent {
16891            status: local_var_status,
16892            content: local_var_content,
16893            entity: local_var_entity,
16894        };
16895        Err(Error::ResponseError(local_var_error))
16896    }
16897}
16898
16899/// API methods for returning or creating notes on an object.
16900pub async fn ipam_vlan_groups_notes_list(
16901    configuration: &configuration::Configuration,
16902    id: &str,
16903    format: Option<&str>,
16904    limit: Option<i32>,
16905    offset: Option<i32>,
16906    depth: Option<i32>,
16907    exclude_m2m: Option<bool>,
16908) -> Result<crate::models::PaginatedNoteList, Error<IpamVlanGroupsNotesListError>> {
16909    let local_var_configuration = configuration;
16910
16911    let local_var_client = &local_var_configuration.client;
16912
16913    let local_var_uri_str = format!(
16914        "{}/ipam/vlan-groups/{id}/notes/",
16915        local_var_configuration.base_path,
16916        id = crate::apis::urlencode(id)
16917    );
16918    let mut local_var_req_builder =
16919        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
16920
16921    if let Some(ref local_var_str) = format {
16922        local_var_req_builder =
16923            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
16924    }
16925    if let Some(ref local_var_str) = limit {
16926        local_var_req_builder =
16927            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
16928    }
16929    if let Some(ref local_var_str) = offset {
16930        local_var_req_builder =
16931            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
16932    }
16933    if let Some(ref local_var_str) = depth {
16934        local_var_req_builder =
16935            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
16936    }
16937    if let Some(ref local_var_str) = exclude_m2m {
16938        local_var_req_builder =
16939            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
16940    }
16941    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16942        local_var_req_builder =
16943            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16944    }
16945    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16946        let local_var_key = local_var_apikey.key.clone();
16947        let local_var_value = match local_var_apikey.prefix {
16948            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16949            None => local_var_key,
16950        };
16951        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16952    };
16953
16954    let local_var_req = local_var_req_builder.build()?;
16955    let local_var_resp = local_var_client.execute(local_var_req).await?;
16956
16957    let local_var_status = local_var_resp.status();
16958    let local_var_content = local_var_resp.text().await?;
16959
16960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16961        serde_json::from_str(&local_var_content).map_err(Error::from)
16962    } else {
16963        let local_var_entity: Option<IpamVlanGroupsNotesListError> =
16964            serde_json::from_str(&local_var_content).ok();
16965        let local_var_error = ResponseContent {
16966            status: local_var_status,
16967            content: local_var_content,
16968            entity: local_var_entity,
16969        };
16970        Err(Error::ResponseError(local_var_error))
16971    }
16972}
16973
16974/// Partial update a VLAN group object.
16975pub async fn ipam_vlan_groups_partial_update(
16976    configuration: &configuration::Configuration,
16977    id: &str,
16978    format: Option<&str>,
16979    patched_vlan_group_request: Option<crate::models::PatchedVlanGroupRequest>,
16980) -> Result<crate::models::VlanGroup, Error<IpamVlanGroupsPartialUpdateError>> {
16981    let local_var_configuration = configuration;
16982
16983    let local_var_client = &local_var_configuration.client;
16984
16985    let local_var_uri_str = format!(
16986        "{}/ipam/vlan-groups/{id}/",
16987        local_var_configuration.base_path,
16988        id = crate::apis::urlencode(id)
16989    );
16990    let mut local_var_req_builder =
16991        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
16992
16993    if let Some(ref local_var_str) = format {
16994        local_var_req_builder =
16995            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
16996    }
16997    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16998        local_var_req_builder =
16999            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17000    }
17001    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17002        let local_var_key = local_var_apikey.key.clone();
17003        let local_var_value = match local_var_apikey.prefix {
17004            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17005            None => local_var_key,
17006        };
17007        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17008    };
17009    local_var_req_builder = local_var_req_builder.json(&patched_vlan_group_request);
17010
17011    let local_var_req = local_var_req_builder.build()?;
17012    let local_var_resp = local_var_client.execute(local_var_req).await?;
17013
17014    let local_var_status = local_var_resp.status();
17015    let local_var_content = local_var_resp.text().await?;
17016
17017    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17018        serde_json::from_str(&local_var_content).map_err(Error::from)
17019    } else {
17020        let local_var_entity: Option<IpamVlanGroupsPartialUpdateError> =
17021            serde_json::from_str(&local_var_content).ok();
17022        let local_var_error = ResponseContent {
17023            status: local_var_status,
17024            content: local_var_content,
17025            entity: local_var_entity,
17026        };
17027        Err(Error::ResponseError(local_var_error))
17028    }
17029}
17030
17031/// Retrieve a VLAN group object.
17032pub async fn ipam_vlan_groups_retrieve(
17033    configuration: &configuration::Configuration,
17034    id: &str,
17035    format: Option<&str>,
17036    depth: Option<i32>,
17037    exclude_m2m: Option<bool>,
17038) -> Result<crate::models::VlanGroup, Error<IpamVlanGroupsRetrieveError>> {
17039    let local_var_configuration = configuration;
17040
17041    let local_var_client = &local_var_configuration.client;
17042
17043    let local_var_uri_str = format!(
17044        "{}/ipam/vlan-groups/{id}/",
17045        local_var_configuration.base_path,
17046        id = crate::apis::urlencode(id)
17047    );
17048    let mut local_var_req_builder =
17049        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17050
17051    if let Some(ref local_var_str) = format {
17052        local_var_req_builder =
17053            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17054    }
17055    if let Some(ref local_var_str) = depth {
17056        local_var_req_builder =
17057            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
17058    }
17059    if let Some(ref local_var_str) = exclude_m2m {
17060        local_var_req_builder =
17061            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
17062    }
17063    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17064        local_var_req_builder =
17065            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17066    }
17067    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17068        let local_var_key = local_var_apikey.key.clone();
17069        let local_var_value = match local_var_apikey.prefix {
17070            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17071            None => local_var_key,
17072        };
17073        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17074    };
17075
17076    let local_var_req = local_var_req_builder.build()?;
17077    let local_var_resp = local_var_client.execute(local_var_req).await?;
17078
17079    let local_var_status = local_var_resp.status();
17080    let local_var_content = local_var_resp.text().await?;
17081
17082    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17083        serde_json::from_str(&local_var_content).map_err(Error::from)
17084    } else {
17085        let local_var_entity: Option<IpamVlanGroupsRetrieveError> =
17086            serde_json::from_str(&local_var_content).ok();
17087        let local_var_error = ResponseContent {
17088            status: local_var_status,
17089            content: local_var_content,
17090            entity: local_var_entity,
17091        };
17092        Err(Error::ResponseError(local_var_error))
17093    }
17094}
17095
17096/// Update a VLAN group object.
17097pub async fn ipam_vlan_groups_update(
17098    configuration: &configuration::Configuration,
17099    id: &str,
17100    vlan_group_request: crate::models::VlanGroupRequest,
17101    format: Option<&str>,
17102) -> Result<crate::models::VlanGroup, Error<IpamVlanGroupsUpdateError>> {
17103    let local_var_configuration = configuration;
17104
17105    let local_var_client = &local_var_configuration.client;
17106
17107    let local_var_uri_str = format!(
17108        "{}/ipam/vlan-groups/{id}/",
17109        local_var_configuration.base_path,
17110        id = crate::apis::urlencode(id)
17111    );
17112    let mut local_var_req_builder =
17113        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17114
17115    if let Some(ref local_var_str) = format {
17116        local_var_req_builder =
17117            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17118    }
17119    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17120        local_var_req_builder =
17121            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17122    }
17123    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17124        let local_var_key = local_var_apikey.key.clone();
17125        let local_var_value = match local_var_apikey.prefix {
17126            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17127            None => local_var_key,
17128        };
17129        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17130    };
17131    local_var_req_builder = local_var_req_builder.json(&vlan_group_request);
17132
17133    let local_var_req = local_var_req_builder.build()?;
17134    let local_var_resp = local_var_client.execute(local_var_req).await?;
17135
17136    let local_var_status = local_var_resp.status();
17137    let local_var_content = local_var_resp.text().await?;
17138
17139    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17140        serde_json::from_str(&local_var_content).map_err(Error::from)
17141    } else {
17142        let local_var_entity: Option<IpamVlanGroupsUpdateError> =
17143            serde_json::from_str(&local_var_content).ok();
17144        let local_var_error = ResponseContent {
17145            status: local_var_status,
17146            content: local_var_content,
17147            entity: local_var_entity,
17148        };
17149        Err(Error::ResponseError(local_var_error))
17150    }
17151}
17152
17153/// Destroy a list of vlan location assignment objects.
17154pub async fn ipam_vlan_location_assignments_bulk_destroy(
17155    configuration: &configuration::Configuration,
17156    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
17157    format: Option<&str>,
17158) -> Result<(), Error<IpamVlanLocationAssignmentsBulkDestroyError>> {
17159    let local_var_configuration = configuration;
17160
17161    let local_var_client = &local_var_configuration.client;
17162
17163    let local_var_uri_str = format!(
17164        "{}/ipam/vlan-location-assignments/",
17165        local_var_configuration.base_path
17166    );
17167    let mut local_var_req_builder =
17168        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17169
17170    if let Some(ref local_var_str) = format {
17171        local_var_req_builder =
17172            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17173    }
17174    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17175        local_var_req_builder =
17176            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17177    }
17178    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17179        let local_var_key = local_var_apikey.key.clone();
17180        let local_var_value = match local_var_apikey.prefix {
17181            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17182            None => local_var_key,
17183        };
17184        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17185    };
17186    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
17187
17188    let local_var_req = local_var_req_builder.build()?;
17189    let local_var_resp = local_var_client.execute(local_var_req).await?;
17190
17191    let local_var_status = local_var_resp.status();
17192    let local_var_content = local_var_resp.text().await?;
17193
17194    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17195        Ok(())
17196    } else {
17197        let local_var_entity: Option<IpamVlanLocationAssignmentsBulkDestroyError> =
17198            serde_json::from_str(&local_var_content).ok();
17199        let local_var_error = ResponseContent {
17200            status: local_var_status,
17201            content: local_var_content,
17202            entity: local_var_entity,
17203        };
17204        Err(Error::ResponseError(local_var_error))
17205    }
17206}
17207
17208/// Partial update a list of vlan location assignment objects.
17209pub async fn ipam_vlan_location_assignments_bulk_partial_update(
17210    configuration: &configuration::Configuration,
17211    patched_bulk_writable_vlan_location_assignment_request: Vec<
17212        crate::models::PatchedBulkWritableVlanLocationAssignmentRequest,
17213    >,
17214    format: Option<&str>,
17215) -> Result<
17216    Vec<crate::models::VlanLocationAssignment>,
17217    Error<IpamVlanLocationAssignmentsBulkPartialUpdateError>,
17218> {
17219    let local_var_configuration = configuration;
17220
17221    let local_var_client = &local_var_configuration.client;
17222
17223    let local_var_uri_str = format!(
17224        "{}/ipam/vlan-location-assignments/",
17225        local_var_configuration.base_path
17226    );
17227    let mut local_var_req_builder =
17228        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17229
17230    if let Some(ref local_var_str) = format {
17231        local_var_req_builder =
17232            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17233    }
17234    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17235        local_var_req_builder =
17236            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17237    }
17238    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17239        let local_var_key = local_var_apikey.key.clone();
17240        let local_var_value = match local_var_apikey.prefix {
17241            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17242            None => local_var_key,
17243        };
17244        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17245    };
17246    local_var_req_builder =
17247        local_var_req_builder.json(&patched_bulk_writable_vlan_location_assignment_request);
17248
17249    let local_var_req = local_var_req_builder.build()?;
17250    let local_var_resp = local_var_client.execute(local_var_req).await?;
17251
17252    let local_var_status = local_var_resp.status();
17253    let local_var_content = local_var_resp.text().await?;
17254
17255    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17256        serde_json::from_str(&local_var_content).map_err(Error::from)
17257    } else {
17258        let local_var_entity: Option<IpamVlanLocationAssignmentsBulkPartialUpdateError> =
17259            serde_json::from_str(&local_var_content).ok();
17260        let local_var_error = ResponseContent {
17261            status: local_var_status,
17262            content: local_var_content,
17263            entity: local_var_entity,
17264        };
17265        Err(Error::ResponseError(local_var_error))
17266    }
17267}
17268
17269/// Update a list of vlan location assignment objects.
17270pub async fn ipam_vlan_location_assignments_bulk_update(
17271    configuration: &configuration::Configuration,
17272    bulk_writable_vlan_location_assignment_request: Vec<
17273        crate::models::BulkWritableVlanLocationAssignmentRequest,
17274    >,
17275    format: Option<&str>,
17276) -> Result<
17277    Vec<crate::models::VlanLocationAssignment>,
17278    Error<IpamVlanLocationAssignmentsBulkUpdateError>,
17279> {
17280    let local_var_configuration = configuration;
17281
17282    let local_var_client = &local_var_configuration.client;
17283
17284    let local_var_uri_str = format!(
17285        "{}/ipam/vlan-location-assignments/",
17286        local_var_configuration.base_path
17287    );
17288    let mut local_var_req_builder =
17289        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17290
17291    if let Some(ref local_var_str) = format {
17292        local_var_req_builder =
17293            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17294    }
17295    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17296        local_var_req_builder =
17297            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17298    }
17299    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17300        let local_var_key = local_var_apikey.key.clone();
17301        let local_var_value = match local_var_apikey.prefix {
17302            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17303            None => local_var_key,
17304        };
17305        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17306    };
17307    local_var_req_builder =
17308        local_var_req_builder.json(&bulk_writable_vlan_location_assignment_request);
17309
17310    let local_var_req = local_var_req_builder.build()?;
17311    let local_var_resp = local_var_client.execute(local_var_req).await?;
17312
17313    let local_var_status = local_var_resp.status();
17314    let local_var_content = local_var_resp.text().await?;
17315
17316    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17317        serde_json::from_str(&local_var_content).map_err(Error::from)
17318    } else {
17319        let local_var_entity: Option<IpamVlanLocationAssignmentsBulkUpdateError> =
17320            serde_json::from_str(&local_var_content).ok();
17321        let local_var_error = ResponseContent {
17322            status: local_var_status,
17323            content: local_var_content,
17324            entity: local_var_entity,
17325        };
17326        Err(Error::ResponseError(local_var_error))
17327    }
17328}
17329
17330/// Create one or more vlan location assignment objects.
17331pub async fn ipam_vlan_location_assignments_create(
17332    configuration: &configuration::Configuration,
17333    vlan_location_assignment_request: crate::models::VlanLocationAssignmentRequest,
17334    format: Option<&str>,
17335) -> Result<crate::models::VlanLocationAssignment, Error<IpamVlanLocationAssignmentsCreateError>> {
17336    let local_var_configuration = configuration;
17337
17338    let local_var_client = &local_var_configuration.client;
17339
17340    let local_var_uri_str = format!(
17341        "{}/ipam/vlan-location-assignments/",
17342        local_var_configuration.base_path
17343    );
17344    let mut local_var_req_builder =
17345        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
17346
17347    if let Some(ref local_var_str) = format {
17348        local_var_req_builder =
17349            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17350    }
17351    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17352        local_var_req_builder =
17353            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17354    }
17355    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17356        let local_var_key = local_var_apikey.key.clone();
17357        let local_var_value = match local_var_apikey.prefix {
17358            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17359            None => local_var_key,
17360        };
17361        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17362    };
17363    local_var_req_builder = local_var_req_builder.json(&vlan_location_assignment_request);
17364
17365    let local_var_req = local_var_req_builder.build()?;
17366    let local_var_resp = local_var_client.execute(local_var_req).await?;
17367
17368    let local_var_status = local_var_resp.status();
17369    let local_var_content = local_var_resp.text().await?;
17370
17371    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17372        serde_json::from_str(&local_var_content).map_err(Error::from)
17373    } else {
17374        let local_var_entity: Option<IpamVlanLocationAssignmentsCreateError> =
17375            serde_json::from_str(&local_var_content).ok();
17376        let local_var_error = ResponseContent {
17377            status: local_var_status,
17378            content: local_var_content,
17379            entity: local_var_entity,
17380        };
17381        Err(Error::ResponseError(local_var_error))
17382    }
17383}
17384
17385/// Destroy a vlan location assignment object.
17386pub async fn ipam_vlan_location_assignments_destroy(
17387    configuration: &configuration::Configuration,
17388    id: &str,
17389    format: Option<&str>,
17390) -> Result<(), Error<IpamVlanLocationAssignmentsDestroyError>> {
17391    let local_var_configuration = configuration;
17392
17393    let local_var_client = &local_var_configuration.client;
17394
17395    let local_var_uri_str = format!(
17396        "{}/ipam/vlan-location-assignments/{id}/",
17397        local_var_configuration.base_path,
17398        id = crate::apis::urlencode(id)
17399    );
17400    let mut local_var_req_builder =
17401        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17402
17403    if let Some(ref local_var_str) = format {
17404        local_var_req_builder =
17405            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17406    }
17407    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17408        local_var_req_builder =
17409            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17410    }
17411    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17412        let local_var_key = local_var_apikey.key.clone();
17413        let local_var_value = match local_var_apikey.prefix {
17414            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17415            None => local_var_key,
17416        };
17417        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17418    };
17419
17420    let local_var_req = local_var_req_builder.build()?;
17421    let local_var_resp = local_var_client.execute(local_var_req).await?;
17422
17423    let local_var_status = local_var_resp.status();
17424    let local_var_content = local_var_resp.text().await?;
17425
17426    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17427        Ok(())
17428    } else {
17429        let local_var_entity: Option<IpamVlanLocationAssignmentsDestroyError> =
17430            serde_json::from_str(&local_var_content).ok();
17431        let local_var_error = ResponseContent {
17432            status: local_var_status,
17433            content: local_var_content,
17434            entity: local_var_entity,
17435        };
17436        Err(Error::ResponseError(local_var_error))
17437    }
17438}
17439
17440/// Retrieve a list of vlan location assignment objects.
17441pub async fn ipam_vlan_location_assignments_list(
17442    configuration: &configuration::Configuration,
17443    created: Option<Vec<String>>,
17444    format: Option<&str>,
17445    id: Option<Vec<uuid::Uuid>>,
17446    id__n: Option<Vec<uuid::Uuid>>,
17447    last_updated: Option<Vec<String>>,
17448    limit: Option<i32>,
17449    location: Option<Vec<String>>,
17450    location__n: Option<Vec<String>>,
17451    offset: Option<i32>,
17452    q: Option<&str>,
17453    sort: Option<&str>,
17454    vlan: Option<Vec<String>>,
17455    vlan__n: Option<Vec<String>>,
17456    depth: Option<i32>,
17457    exclude_m2m: Option<bool>,
17458) -> Result<
17459    crate::models::PaginatedVlanLocationAssignmentList,
17460    Error<IpamVlanLocationAssignmentsListError>,
17461> {
17462    let local_var_configuration = configuration;
17463
17464    let local_var_client = &local_var_configuration.client;
17465
17466    let local_var_uri_str = format!(
17467        "{}/ipam/vlan-location-assignments/",
17468        local_var_configuration.base_path
17469    );
17470    let mut local_var_req_builder =
17471        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17472
17473    if let Some(ref local_var_str) = created {
17474        local_var_req_builder = match "multi" {
17475            "multi" => local_var_req_builder.query(
17476                &local_var_str
17477                    .into_iter()
17478                    .map(|p| ("created".to_owned(), p.to_string()))
17479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17480            ),
17481            _ => local_var_req_builder.query(&[(
17482                "created",
17483                &local_var_str
17484                    .into_iter()
17485                    .map(|p| p.to_string())
17486                    .collect::<Vec<String>>()
17487                    .join(",")
17488                    .to_string(),
17489            )]),
17490        };
17491    }
17492    if let Some(ref local_var_str) = format {
17493        local_var_req_builder =
17494            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17495    }
17496    if let Some(ref local_var_str) = id {
17497        local_var_req_builder = match "multi" {
17498            "multi" => local_var_req_builder.query(
17499                &local_var_str
17500                    .into_iter()
17501                    .map(|p| ("id".to_owned(), p.to_string()))
17502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17503            ),
17504            _ => local_var_req_builder.query(&[(
17505                "id",
17506                &local_var_str
17507                    .into_iter()
17508                    .map(|p| p.to_string())
17509                    .collect::<Vec<String>>()
17510                    .join(",")
17511                    .to_string(),
17512            )]),
17513        };
17514    }
17515    if let Some(ref local_var_str) = id__n {
17516        local_var_req_builder = match "multi" {
17517            "multi" => local_var_req_builder.query(
17518                &local_var_str
17519                    .into_iter()
17520                    .map(|p| ("id__n".to_owned(), p.to_string()))
17521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17522            ),
17523            _ => local_var_req_builder.query(&[(
17524                "id__n",
17525                &local_var_str
17526                    .into_iter()
17527                    .map(|p| p.to_string())
17528                    .collect::<Vec<String>>()
17529                    .join(",")
17530                    .to_string(),
17531            )]),
17532        };
17533    }
17534    if let Some(ref local_var_str) = last_updated {
17535        local_var_req_builder = match "multi" {
17536            "multi" => local_var_req_builder.query(
17537                &local_var_str
17538                    .into_iter()
17539                    .map(|p| ("last_updated".to_owned(), p.to_string()))
17540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17541            ),
17542            _ => local_var_req_builder.query(&[(
17543                "last_updated",
17544                &local_var_str
17545                    .into_iter()
17546                    .map(|p| p.to_string())
17547                    .collect::<Vec<String>>()
17548                    .join(",")
17549                    .to_string(),
17550            )]),
17551        };
17552    }
17553    if let Some(ref local_var_str) = limit {
17554        local_var_req_builder =
17555            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
17556    }
17557    if let Some(ref local_var_str) = location {
17558        local_var_req_builder = match "multi" {
17559            "multi" => local_var_req_builder.query(
17560                &local_var_str
17561                    .into_iter()
17562                    .map(|p| ("location".to_owned(), p.to_string()))
17563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17564            ),
17565            _ => local_var_req_builder.query(&[(
17566                "location",
17567                &local_var_str
17568                    .into_iter()
17569                    .map(|p| p.to_string())
17570                    .collect::<Vec<String>>()
17571                    .join(",")
17572                    .to_string(),
17573            )]),
17574        };
17575    }
17576    if let Some(ref local_var_str) = location__n {
17577        local_var_req_builder = match "multi" {
17578            "multi" => local_var_req_builder.query(
17579                &local_var_str
17580                    .into_iter()
17581                    .map(|p| ("location__n".to_owned(), p.to_string()))
17582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17583            ),
17584            _ => local_var_req_builder.query(&[(
17585                "location__n",
17586                &local_var_str
17587                    .into_iter()
17588                    .map(|p| p.to_string())
17589                    .collect::<Vec<String>>()
17590                    .join(",")
17591                    .to_string(),
17592            )]),
17593        };
17594    }
17595    if let Some(ref local_var_str) = offset {
17596        local_var_req_builder =
17597            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
17598    }
17599    if let Some(ref local_var_str) = q {
17600        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
17601    }
17602    if let Some(ref local_var_str) = sort {
17603        local_var_req_builder =
17604            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
17605    }
17606    if let Some(ref local_var_str) = vlan {
17607        local_var_req_builder = match "multi" {
17608            "multi" => local_var_req_builder.query(
17609                &local_var_str
17610                    .into_iter()
17611                    .map(|p| ("vlan".to_owned(), p.to_string()))
17612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17613            ),
17614            _ => local_var_req_builder.query(&[(
17615                "vlan",
17616                &local_var_str
17617                    .into_iter()
17618                    .map(|p| p.to_string())
17619                    .collect::<Vec<String>>()
17620                    .join(",")
17621                    .to_string(),
17622            )]),
17623        };
17624    }
17625    if let Some(ref local_var_str) = vlan__n {
17626        local_var_req_builder = match "multi" {
17627            "multi" => local_var_req_builder.query(
17628                &local_var_str
17629                    .into_iter()
17630                    .map(|p| ("vlan__n".to_owned(), p.to_string()))
17631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17632            ),
17633            _ => local_var_req_builder.query(&[(
17634                "vlan__n",
17635                &local_var_str
17636                    .into_iter()
17637                    .map(|p| p.to_string())
17638                    .collect::<Vec<String>>()
17639                    .join(",")
17640                    .to_string(),
17641            )]),
17642        };
17643    }
17644    if let Some(ref local_var_str) = depth {
17645        local_var_req_builder =
17646            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
17647    }
17648    if let Some(ref local_var_str) = exclude_m2m {
17649        local_var_req_builder =
17650            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
17651    }
17652    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17653        local_var_req_builder =
17654            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17655    }
17656    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17657        let local_var_key = local_var_apikey.key.clone();
17658        let local_var_value = match local_var_apikey.prefix {
17659            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17660            None => local_var_key,
17661        };
17662        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17663    };
17664
17665    let local_var_req = local_var_req_builder.build()?;
17666    let local_var_resp = local_var_client.execute(local_var_req).await?;
17667
17668    let local_var_status = local_var_resp.status();
17669    let local_var_content = local_var_resp.text().await?;
17670
17671    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17672        serde_json::from_str(&local_var_content).map_err(Error::from)
17673    } else {
17674        let local_var_entity: Option<IpamVlanLocationAssignmentsListError> =
17675            serde_json::from_str(&local_var_content).ok();
17676        let local_var_error = ResponseContent {
17677            status: local_var_status,
17678            content: local_var_content,
17679            entity: local_var_entity,
17680        };
17681        Err(Error::ResponseError(local_var_error))
17682    }
17683}
17684
17685/// Partial update a vlan location assignment object.
17686pub async fn ipam_vlan_location_assignments_partial_update(
17687    configuration: &configuration::Configuration,
17688    id: &str,
17689    format: Option<&str>,
17690    patched_vlan_location_assignment_request: Option<
17691        crate::models::PatchedVlanLocationAssignmentRequest,
17692    >,
17693) -> Result<
17694    crate::models::VlanLocationAssignment,
17695    Error<IpamVlanLocationAssignmentsPartialUpdateError>,
17696> {
17697    let local_var_configuration = configuration;
17698
17699    let local_var_client = &local_var_configuration.client;
17700
17701    let local_var_uri_str = format!(
17702        "{}/ipam/vlan-location-assignments/{id}/",
17703        local_var_configuration.base_path,
17704        id = crate::apis::urlencode(id)
17705    );
17706    let mut local_var_req_builder =
17707        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17708
17709    if let Some(ref local_var_str) = format {
17710        local_var_req_builder =
17711            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17712    }
17713    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17714        local_var_req_builder =
17715            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17716    }
17717    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17718        let local_var_key = local_var_apikey.key.clone();
17719        let local_var_value = match local_var_apikey.prefix {
17720            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17721            None => local_var_key,
17722        };
17723        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17724    };
17725    local_var_req_builder = local_var_req_builder.json(&patched_vlan_location_assignment_request);
17726
17727    let local_var_req = local_var_req_builder.build()?;
17728    let local_var_resp = local_var_client.execute(local_var_req).await?;
17729
17730    let local_var_status = local_var_resp.status();
17731    let local_var_content = local_var_resp.text().await?;
17732
17733    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17734        serde_json::from_str(&local_var_content).map_err(Error::from)
17735    } else {
17736        let local_var_entity: Option<IpamVlanLocationAssignmentsPartialUpdateError> =
17737            serde_json::from_str(&local_var_content).ok();
17738        let local_var_error = ResponseContent {
17739            status: local_var_status,
17740            content: local_var_content,
17741            entity: local_var_entity,
17742        };
17743        Err(Error::ResponseError(local_var_error))
17744    }
17745}
17746
17747/// Retrieve a vlan location assignment object.
17748pub async fn ipam_vlan_location_assignments_retrieve(
17749    configuration: &configuration::Configuration,
17750    id: &str,
17751    format: Option<&str>,
17752    depth: Option<i32>,
17753    exclude_m2m: Option<bool>,
17754) -> Result<crate::models::VlanLocationAssignment, Error<IpamVlanLocationAssignmentsRetrieveError>>
17755{
17756    let local_var_configuration = configuration;
17757
17758    let local_var_client = &local_var_configuration.client;
17759
17760    let local_var_uri_str = format!(
17761        "{}/ipam/vlan-location-assignments/{id}/",
17762        local_var_configuration.base_path,
17763        id = crate::apis::urlencode(id)
17764    );
17765    let mut local_var_req_builder =
17766        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17767
17768    if let Some(ref local_var_str) = format {
17769        local_var_req_builder =
17770            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17771    }
17772    if let Some(ref local_var_str) = depth {
17773        local_var_req_builder =
17774            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
17775    }
17776    if let Some(ref local_var_str) = exclude_m2m {
17777        local_var_req_builder =
17778            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
17779    }
17780    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17781        local_var_req_builder =
17782            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17783    }
17784    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17785        let local_var_key = local_var_apikey.key.clone();
17786        let local_var_value = match local_var_apikey.prefix {
17787            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17788            None => local_var_key,
17789        };
17790        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17791    };
17792
17793    let local_var_req = local_var_req_builder.build()?;
17794    let local_var_resp = local_var_client.execute(local_var_req).await?;
17795
17796    let local_var_status = local_var_resp.status();
17797    let local_var_content = local_var_resp.text().await?;
17798
17799    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17800        serde_json::from_str(&local_var_content).map_err(Error::from)
17801    } else {
17802        let local_var_entity: Option<IpamVlanLocationAssignmentsRetrieveError> =
17803            serde_json::from_str(&local_var_content).ok();
17804        let local_var_error = ResponseContent {
17805            status: local_var_status,
17806            content: local_var_content,
17807            entity: local_var_entity,
17808        };
17809        Err(Error::ResponseError(local_var_error))
17810    }
17811}
17812
17813/// Update a vlan location assignment object.
17814pub async fn ipam_vlan_location_assignments_update(
17815    configuration: &configuration::Configuration,
17816    id: &str,
17817    vlan_location_assignment_request: crate::models::VlanLocationAssignmentRequest,
17818    format: Option<&str>,
17819) -> Result<crate::models::VlanLocationAssignment, Error<IpamVlanLocationAssignmentsUpdateError>> {
17820    let local_var_configuration = configuration;
17821
17822    let local_var_client = &local_var_configuration.client;
17823
17824    let local_var_uri_str = format!(
17825        "{}/ipam/vlan-location-assignments/{id}/",
17826        local_var_configuration.base_path,
17827        id = crate::apis::urlencode(id)
17828    );
17829    let mut local_var_req_builder =
17830        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17831
17832    if let Some(ref local_var_str) = format {
17833        local_var_req_builder =
17834            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17835    }
17836    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17837        local_var_req_builder =
17838            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17839    }
17840    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17841        let local_var_key = local_var_apikey.key.clone();
17842        let local_var_value = match local_var_apikey.prefix {
17843            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17844            None => local_var_key,
17845        };
17846        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17847    };
17848    local_var_req_builder = local_var_req_builder.json(&vlan_location_assignment_request);
17849
17850    let local_var_req = local_var_req_builder.build()?;
17851    let local_var_resp = local_var_client.execute(local_var_req).await?;
17852
17853    let local_var_status = local_var_resp.status();
17854    let local_var_content = local_var_resp.text().await?;
17855
17856    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17857        serde_json::from_str(&local_var_content).map_err(Error::from)
17858    } else {
17859        let local_var_entity: Option<IpamVlanLocationAssignmentsUpdateError> =
17860            serde_json::from_str(&local_var_content).ok();
17861        let local_var_error = ResponseContent {
17862            status: local_var_status,
17863            content: local_var_content,
17864            entity: local_var_entity,
17865        };
17866        Err(Error::ResponseError(local_var_error))
17867    }
17868}
17869
17870/// Destroy a list of VLAN objects.
17871pub async fn ipam_vlans_bulk_destroy(
17872    configuration: &configuration::Configuration,
17873    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
17874    format: Option<&str>,
17875) -> Result<(), Error<IpamVlansBulkDestroyError>> {
17876    let local_var_configuration = configuration;
17877
17878    let local_var_client = &local_var_configuration.client;
17879
17880    let local_var_uri_str = format!("{}/ipam/vlans/", local_var_configuration.base_path);
17881    let mut local_var_req_builder =
17882        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17883
17884    if let Some(ref local_var_str) = format {
17885        local_var_req_builder =
17886            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17887    }
17888    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17889        local_var_req_builder =
17890            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17891    }
17892    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17893        let local_var_key = local_var_apikey.key.clone();
17894        let local_var_value = match local_var_apikey.prefix {
17895            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17896            None => local_var_key,
17897        };
17898        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17899    };
17900    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
17901
17902    let local_var_req = local_var_req_builder.build()?;
17903    let local_var_resp = local_var_client.execute(local_var_req).await?;
17904
17905    let local_var_status = local_var_resp.status();
17906    let local_var_content = local_var_resp.text().await?;
17907
17908    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17909        Ok(())
17910    } else {
17911        let local_var_entity: Option<IpamVlansBulkDestroyError> =
17912            serde_json::from_str(&local_var_content).ok();
17913        let local_var_error = ResponseContent {
17914            status: local_var_status,
17915            content: local_var_content,
17916            entity: local_var_entity,
17917        };
17918        Err(Error::ResponseError(local_var_error))
17919    }
17920}
17921
17922/// Partial update a list of VLAN objects.
17923pub async fn ipam_vlans_bulk_partial_update(
17924    configuration: &configuration::Configuration,
17925    patched_bulk_writable_vlan_request: Vec<crate::models::PatchedBulkWritableVlanRequest>,
17926    format: Option<&str>,
17927) -> Result<Vec<crate::models::Vlan>, Error<IpamVlansBulkPartialUpdateError>> {
17928    let local_var_configuration = configuration;
17929
17930    let local_var_client = &local_var_configuration.client;
17931
17932    let local_var_uri_str = format!("{}/ipam/vlans/", local_var_configuration.base_path);
17933    let mut local_var_req_builder =
17934        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17935
17936    if let Some(ref local_var_str) = format {
17937        local_var_req_builder =
17938            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17939    }
17940    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17941        local_var_req_builder =
17942            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17943    }
17944    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17945        let local_var_key = local_var_apikey.key.clone();
17946        let local_var_value = match local_var_apikey.prefix {
17947            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17948            None => local_var_key,
17949        };
17950        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17951    };
17952    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vlan_request);
17953
17954    let local_var_req = local_var_req_builder.build()?;
17955    let local_var_resp = local_var_client.execute(local_var_req).await?;
17956
17957    let local_var_status = local_var_resp.status();
17958    let local_var_content = local_var_resp.text().await?;
17959
17960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17961        serde_json::from_str(&local_var_content).map_err(Error::from)
17962    } else {
17963        let local_var_entity: Option<IpamVlansBulkPartialUpdateError> =
17964            serde_json::from_str(&local_var_content).ok();
17965        let local_var_error = ResponseContent {
17966            status: local_var_status,
17967            content: local_var_content,
17968            entity: local_var_entity,
17969        };
17970        Err(Error::ResponseError(local_var_error))
17971    }
17972}
17973
17974/// Update a list of VLAN objects.
17975pub async fn ipam_vlans_bulk_update(
17976    configuration: &configuration::Configuration,
17977    bulk_writable_vlan_request: Vec<crate::models::BulkWritableVlanRequest>,
17978    format: Option<&str>,
17979) -> Result<Vec<crate::models::Vlan>, Error<IpamVlansBulkUpdateError>> {
17980    let local_var_configuration = configuration;
17981
17982    let local_var_client = &local_var_configuration.client;
17983
17984    let local_var_uri_str = format!("{}/ipam/vlans/", local_var_configuration.base_path);
17985    let mut local_var_req_builder =
17986        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17987
17988    if let Some(ref local_var_str) = format {
17989        local_var_req_builder =
17990            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17991    }
17992    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17993        local_var_req_builder =
17994            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17995    }
17996    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17997        let local_var_key = local_var_apikey.key.clone();
17998        let local_var_value = match local_var_apikey.prefix {
17999            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18000            None => local_var_key,
18001        };
18002        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18003    };
18004    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vlan_request);
18005
18006    let local_var_req = local_var_req_builder.build()?;
18007    let local_var_resp = local_var_client.execute(local_var_req).await?;
18008
18009    let local_var_status = local_var_resp.status();
18010    let local_var_content = local_var_resp.text().await?;
18011
18012    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18013        serde_json::from_str(&local_var_content).map_err(Error::from)
18014    } else {
18015        let local_var_entity: Option<IpamVlansBulkUpdateError> =
18016            serde_json::from_str(&local_var_content).ok();
18017        let local_var_error = ResponseContent {
18018            status: local_var_status,
18019            content: local_var_content,
18020            entity: local_var_entity,
18021        };
18022        Err(Error::ResponseError(local_var_error))
18023    }
18024}
18025
18026/// Create one or more VLAN objects.
18027pub async fn ipam_vlans_create(
18028    configuration: &configuration::Configuration,
18029    vlan_request: crate::models::VlanRequest,
18030    format: Option<&str>,
18031) -> Result<crate::models::Vlan, Error<IpamVlansCreateError>> {
18032    let local_var_configuration = configuration;
18033
18034    let local_var_client = &local_var_configuration.client;
18035
18036    let local_var_uri_str = format!("{}/ipam/vlans/", local_var_configuration.base_path);
18037    let mut local_var_req_builder =
18038        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
18039
18040    if let Some(ref local_var_str) = format {
18041        local_var_req_builder =
18042            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18043    }
18044    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18045        local_var_req_builder =
18046            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18047    }
18048    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18049        let local_var_key = local_var_apikey.key.clone();
18050        let local_var_value = match local_var_apikey.prefix {
18051            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18052            None => local_var_key,
18053        };
18054        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18055    };
18056    local_var_req_builder = local_var_req_builder.json(&vlan_request);
18057
18058    let local_var_req = local_var_req_builder.build()?;
18059    let local_var_resp = local_var_client.execute(local_var_req).await?;
18060
18061    let local_var_status = local_var_resp.status();
18062    let local_var_content = local_var_resp.text().await?;
18063
18064    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18065        serde_json::from_str(&local_var_content).map_err(Error::from)
18066    } else {
18067        let local_var_entity: Option<IpamVlansCreateError> =
18068            serde_json::from_str(&local_var_content).ok();
18069        let local_var_error = ResponseContent {
18070            status: local_var_status,
18071            content: local_var_content,
18072            entity: local_var_entity,
18073        };
18074        Err(Error::ResponseError(local_var_error))
18075    }
18076}
18077
18078/// Destroy a VLAN object.
18079pub async fn ipam_vlans_destroy(
18080    configuration: &configuration::Configuration,
18081    id: &str,
18082    format: Option<&str>,
18083) -> Result<(), Error<IpamVlansDestroyError>> {
18084    let local_var_configuration = configuration;
18085
18086    let local_var_client = &local_var_configuration.client;
18087
18088    let local_var_uri_str = format!(
18089        "{}/ipam/vlans/{id}/",
18090        local_var_configuration.base_path,
18091        id = crate::apis::urlencode(id)
18092    );
18093    let mut local_var_req_builder =
18094        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
18095
18096    if let Some(ref local_var_str) = format {
18097        local_var_req_builder =
18098            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18099    }
18100    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18101        local_var_req_builder =
18102            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18103    }
18104    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18105        let local_var_key = local_var_apikey.key.clone();
18106        let local_var_value = match local_var_apikey.prefix {
18107            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18108            None => local_var_key,
18109        };
18110        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18111    };
18112
18113    let local_var_req = local_var_req_builder.build()?;
18114    let local_var_resp = local_var_client.execute(local_var_req).await?;
18115
18116    let local_var_status = local_var_resp.status();
18117    let local_var_content = local_var_resp.text().await?;
18118
18119    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18120        Ok(())
18121    } else {
18122        let local_var_entity: Option<IpamVlansDestroyError> =
18123            serde_json::from_str(&local_var_content).ok();
18124        let local_var_error = ResponseContent {
18125            status: local_var_status,
18126            content: local_var_content,
18127            entity: local_var_entity,
18128        };
18129        Err(Error::ResponseError(local_var_error))
18130    }
18131}
18132
18133/// Retrieve a list of VLAN objects.
18134pub async fn ipam_vlans_list(
18135    configuration: &configuration::Configuration,
18136    available_on_device: Option<Vec<uuid::Uuid>>,
18137    contacts: Option<Vec<String>>,
18138    contacts__isnull: Option<bool>,
18139    contacts__n: Option<Vec<String>>,
18140    created: Option<Vec<String>>,
18141    created__gt: Option<Vec<String>>,
18142    created__gte: Option<Vec<String>>,
18143    created__isnull: Option<bool>,
18144    created__lt: Option<Vec<String>>,
18145    created__lte: Option<Vec<String>>,
18146    created__n: Option<Vec<String>>,
18147    dynamic_groups: Option<Vec<String>>,
18148    dynamic_groups__n: Option<Vec<String>>,
18149    format: Option<&str>,
18150    id: Option<Vec<uuid::Uuid>>,
18151    id__n: Option<Vec<uuid::Uuid>>,
18152    last_updated: Option<Vec<String>>,
18153    last_updated__gt: Option<Vec<String>>,
18154    last_updated__gte: Option<Vec<String>>,
18155    last_updated__isnull: Option<bool>,
18156    last_updated__lt: Option<Vec<String>>,
18157    last_updated__lte: Option<Vec<String>>,
18158    last_updated__n: Option<Vec<String>>,
18159    limit: Option<i32>,
18160    location: Option<Vec<String>>,
18161    location__n: Option<Vec<String>>,
18162    locations: Option<Vec<String>>,
18163    locations__n: Option<Vec<String>>,
18164    name: Option<Vec<String>>,
18165    name__ic: Option<Vec<String>>,
18166    name__ie: Option<Vec<String>>,
18167    name__iew: Option<Vec<String>>,
18168    name__ire: Option<Vec<String>>,
18169    name__isw: Option<Vec<String>>,
18170    name__n: Option<Vec<String>>,
18171    name__nic: Option<Vec<String>>,
18172    name__nie: Option<Vec<String>>,
18173    name__niew: Option<Vec<String>>,
18174    name__nire: Option<Vec<String>>,
18175    name__nisw: Option<Vec<String>>,
18176    name__nre: Option<Vec<String>>,
18177    name__re: Option<Vec<String>>,
18178    offset: Option<i32>,
18179    q: Option<&str>,
18180    role: Option<Vec<String>>,
18181    role__isnull: Option<bool>,
18182    role__n: Option<Vec<String>>,
18183    sort: Option<&str>,
18184    status: Option<Vec<String>>,
18185    status__n: Option<Vec<String>>,
18186    tags: Option<Vec<String>>,
18187    tags__isnull: Option<bool>,
18188    tags__n: Option<Vec<String>>,
18189    teams: Option<Vec<String>>,
18190    teams__isnull: Option<bool>,
18191    teams__n: Option<Vec<String>>,
18192    tenant: Option<Vec<String>>,
18193    tenant__isnull: Option<bool>,
18194    tenant__n: Option<Vec<String>>,
18195    tenant_group: Option<Vec<String>>,
18196    tenant_group__isnull: Option<bool>,
18197    tenant_group__n: Option<Vec<String>>,
18198    tenant_id: Option<Vec<uuid::Uuid>>,
18199    tenant_id__isnull: Option<bool>,
18200    tenant_id__n: Option<Vec<uuid::Uuid>>,
18201    vid: Option<Vec<i32>>,
18202    vid__gt: Option<Vec<i32>>,
18203    vid__gte: Option<Vec<i32>>,
18204    vid__lt: Option<Vec<i32>>,
18205    vid__lte: Option<Vec<i32>>,
18206    vid__n: Option<Vec<i32>>,
18207    vlan_group: Option<Vec<String>>,
18208    vlan_group__isnull: Option<bool>,
18209    vlan_group__n: Option<Vec<String>>,
18210    depth: Option<i32>,
18211    exclude_m2m: Option<bool>,
18212) -> Result<crate::models::PaginatedVlanList, Error<IpamVlansListError>> {
18213    let local_var_configuration = configuration;
18214
18215    let local_var_client = &local_var_configuration.client;
18216
18217    let local_var_uri_str = format!("{}/ipam/vlans/", local_var_configuration.base_path);
18218    let mut local_var_req_builder =
18219        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
18220
18221    if let Some(ref local_var_str) = available_on_device {
18222        local_var_req_builder = match "multi" {
18223            "multi" => local_var_req_builder.query(
18224                &local_var_str
18225                    .into_iter()
18226                    .map(|p| ("available_on_device".to_owned(), p.to_string()))
18227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18228            ),
18229            _ => local_var_req_builder.query(&[(
18230                "available_on_device",
18231                &local_var_str
18232                    .into_iter()
18233                    .map(|p| p.to_string())
18234                    .collect::<Vec<String>>()
18235                    .join(",")
18236                    .to_string(),
18237            )]),
18238        };
18239    }
18240    if let Some(ref local_var_str) = contacts {
18241        local_var_req_builder = match "multi" {
18242            "multi" => local_var_req_builder.query(
18243                &local_var_str
18244                    .into_iter()
18245                    .map(|p| ("contacts".to_owned(), p.to_string()))
18246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18247            ),
18248            _ => local_var_req_builder.query(&[(
18249                "contacts",
18250                &local_var_str
18251                    .into_iter()
18252                    .map(|p| p.to_string())
18253                    .collect::<Vec<String>>()
18254                    .join(",")
18255                    .to_string(),
18256            )]),
18257        };
18258    }
18259    if let Some(ref local_var_str) = contacts__isnull {
18260        local_var_req_builder =
18261            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
18262    }
18263    if let Some(ref local_var_str) = contacts__n {
18264        local_var_req_builder = match "multi" {
18265            "multi" => local_var_req_builder.query(
18266                &local_var_str
18267                    .into_iter()
18268                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
18269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18270            ),
18271            _ => local_var_req_builder.query(&[(
18272                "contacts__n",
18273                &local_var_str
18274                    .into_iter()
18275                    .map(|p| p.to_string())
18276                    .collect::<Vec<String>>()
18277                    .join(",")
18278                    .to_string(),
18279            )]),
18280        };
18281    }
18282    if let Some(ref local_var_str) = created {
18283        local_var_req_builder = match "multi" {
18284            "multi" => local_var_req_builder.query(
18285                &local_var_str
18286                    .into_iter()
18287                    .map(|p| ("created".to_owned(), p.to_string()))
18288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18289            ),
18290            _ => local_var_req_builder.query(&[(
18291                "created",
18292                &local_var_str
18293                    .into_iter()
18294                    .map(|p| p.to_string())
18295                    .collect::<Vec<String>>()
18296                    .join(",")
18297                    .to_string(),
18298            )]),
18299        };
18300    }
18301    if let Some(ref local_var_str) = created__gt {
18302        local_var_req_builder = match "multi" {
18303            "multi" => local_var_req_builder.query(
18304                &local_var_str
18305                    .into_iter()
18306                    .map(|p| ("created__gt".to_owned(), p.to_string()))
18307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18308            ),
18309            _ => local_var_req_builder.query(&[(
18310                "created__gt",
18311                &local_var_str
18312                    .into_iter()
18313                    .map(|p| p.to_string())
18314                    .collect::<Vec<String>>()
18315                    .join(",")
18316                    .to_string(),
18317            )]),
18318        };
18319    }
18320    if let Some(ref local_var_str) = created__gte {
18321        local_var_req_builder = match "multi" {
18322            "multi" => local_var_req_builder.query(
18323                &local_var_str
18324                    .into_iter()
18325                    .map(|p| ("created__gte".to_owned(), p.to_string()))
18326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18327            ),
18328            _ => local_var_req_builder.query(&[(
18329                "created__gte",
18330                &local_var_str
18331                    .into_iter()
18332                    .map(|p| p.to_string())
18333                    .collect::<Vec<String>>()
18334                    .join(",")
18335                    .to_string(),
18336            )]),
18337        };
18338    }
18339    if let Some(ref local_var_str) = created__isnull {
18340        local_var_req_builder =
18341            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
18342    }
18343    if let Some(ref local_var_str) = created__lt {
18344        local_var_req_builder = match "multi" {
18345            "multi" => local_var_req_builder.query(
18346                &local_var_str
18347                    .into_iter()
18348                    .map(|p| ("created__lt".to_owned(), p.to_string()))
18349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18350            ),
18351            _ => local_var_req_builder.query(&[(
18352                "created__lt",
18353                &local_var_str
18354                    .into_iter()
18355                    .map(|p| p.to_string())
18356                    .collect::<Vec<String>>()
18357                    .join(",")
18358                    .to_string(),
18359            )]),
18360        };
18361    }
18362    if let Some(ref local_var_str) = created__lte {
18363        local_var_req_builder = match "multi" {
18364            "multi" => local_var_req_builder.query(
18365                &local_var_str
18366                    .into_iter()
18367                    .map(|p| ("created__lte".to_owned(), p.to_string()))
18368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18369            ),
18370            _ => local_var_req_builder.query(&[(
18371                "created__lte",
18372                &local_var_str
18373                    .into_iter()
18374                    .map(|p| p.to_string())
18375                    .collect::<Vec<String>>()
18376                    .join(",")
18377                    .to_string(),
18378            )]),
18379        };
18380    }
18381    if let Some(ref local_var_str) = created__n {
18382        local_var_req_builder = match "multi" {
18383            "multi" => local_var_req_builder.query(
18384                &local_var_str
18385                    .into_iter()
18386                    .map(|p| ("created__n".to_owned(), p.to_string()))
18387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18388            ),
18389            _ => local_var_req_builder.query(&[(
18390                "created__n",
18391                &local_var_str
18392                    .into_iter()
18393                    .map(|p| p.to_string())
18394                    .collect::<Vec<String>>()
18395                    .join(",")
18396                    .to_string(),
18397            )]),
18398        };
18399    }
18400    if let Some(ref local_var_str) = dynamic_groups {
18401        local_var_req_builder = match "multi" {
18402            "multi" => local_var_req_builder.query(
18403                &local_var_str
18404                    .into_iter()
18405                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
18406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18407            ),
18408            _ => local_var_req_builder.query(&[(
18409                "dynamic_groups",
18410                &local_var_str
18411                    .into_iter()
18412                    .map(|p| p.to_string())
18413                    .collect::<Vec<String>>()
18414                    .join(",")
18415                    .to_string(),
18416            )]),
18417        };
18418    }
18419    if let Some(ref local_var_str) = dynamic_groups__n {
18420        local_var_req_builder = match "multi" {
18421            "multi" => local_var_req_builder.query(
18422                &local_var_str
18423                    .into_iter()
18424                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
18425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18426            ),
18427            _ => local_var_req_builder.query(&[(
18428                "dynamic_groups__n",
18429                &local_var_str
18430                    .into_iter()
18431                    .map(|p| p.to_string())
18432                    .collect::<Vec<String>>()
18433                    .join(",")
18434                    .to_string(),
18435            )]),
18436        };
18437    }
18438    if let Some(ref local_var_str) = format {
18439        local_var_req_builder =
18440            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18441    }
18442    if let Some(ref local_var_str) = id {
18443        local_var_req_builder = match "multi" {
18444            "multi" => local_var_req_builder.query(
18445                &local_var_str
18446                    .into_iter()
18447                    .map(|p| ("id".to_owned(), p.to_string()))
18448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18449            ),
18450            _ => local_var_req_builder.query(&[(
18451                "id",
18452                &local_var_str
18453                    .into_iter()
18454                    .map(|p| p.to_string())
18455                    .collect::<Vec<String>>()
18456                    .join(",")
18457                    .to_string(),
18458            )]),
18459        };
18460    }
18461    if let Some(ref local_var_str) = id__n {
18462        local_var_req_builder = match "multi" {
18463            "multi" => local_var_req_builder.query(
18464                &local_var_str
18465                    .into_iter()
18466                    .map(|p| ("id__n".to_owned(), p.to_string()))
18467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18468            ),
18469            _ => local_var_req_builder.query(&[(
18470                "id__n",
18471                &local_var_str
18472                    .into_iter()
18473                    .map(|p| p.to_string())
18474                    .collect::<Vec<String>>()
18475                    .join(",")
18476                    .to_string(),
18477            )]),
18478        };
18479    }
18480    if let Some(ref local_var_str) = last_updated {
18481        local_var_req_builder = match "multi" {
18482            "multi" => local_var_req_builder.query(
18483                &local_var_str
18484                    .into_iter()
18485                    .map(|p| ("last_updated".to_owned(), p.to_string()))
18486                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18487            ),
18488            _ => local_var_req_builder.query(&[(
18489                "last_updated",
18490                &local_var_str
18491                    .into_iter()
18492                    .map(|p| p.to_string())
18493                    .collect::<Vec<String>>()
18494                    .join(",")
18495                    .to_string(),
18496            )]),
18497        };
18498    }
18499    if let Some(ref local_var_str) = last_updated__gt {
18500        local_var_req_builder = match "multi" {
18501            "multi" => local_var_req_builder.query(
18502                &local_var_str
18503                    .into_iter()
18504                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
18505                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18506            ),
18507            _ => local_var_req_builder.query(&[(
18508                "last_updated__gt",
18509                &local_var_str
18510                    .into_iter()
18511                    .map(|p| p.to_string())
18512                    .collect::<Vec<String>>()
18513                    .join(",")
18514                    .to_string(),
18515            )]),
18516        };
18517    }
18518    if let Some(ref local_var_str) = last_updated__gte {
18519        local_var_req_builder = match "multi" {
18520            "multi" => local_var_req_builder.query(
18521                &local_var_str
18522                    .into_iter()
18523                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
18524                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18525            ),
18526            _ => local_var_req_builder.query(&[(
18527                "last_updated__gte",
18528                &local_var_str
18529                    .into_iter()
18530                    .map(|p| p.to_string())
18531                    .collect::<Vec<String>>()
18532                    .join(",")
18533                    .to_string(),
18534            )]),
18535        };
18536    }
18537    if let Some(ref local_var_str) = last_updated__isnull {
18538        local_var_req_builder =
18539            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
18540    }
18541    if let Some(ref local_var_str) = last_updated__lt {
18542        local_var_req_builder = match "multi" {
18543            "multi" => local_var_req_builder.query(
18544                &local_var_str
18545                    .into_iter()
18546                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
18547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18548            ),
18549            _ => local_var_req_builder.query(&[(
18550                "last_updated__lt",
18551                &local_var_str
18552                    .into_iter()
18553                    .map(|p| p.to_string())
18554                    .collect::<Vec<String>>()
18555                    .join(",")
18556                    .to_string(),
18557            )]),
18558        };
18559    }
18560    if let Some(ref local_var_str) = last_updated__lte {
18561        local_var_req_builder = match "multi" {
18562            "multi" => local_var_req_builder.query(
18563                &local_var_str
18564                    .into_iter()
18565                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
18566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18567            ),
18568            _ => local_var_req_builder.query(&[(
18569                "last_updated__lte",
18570                &local_var_str
18571                    .into_iter()
18572                    .map(|p| p.to_string())
18573                    .collect::<Vec<String>>()
18574                    .join(",")
18575                    .to_string(),
18576            )]),
18577        };
18578    }
18579    if let Some(ref local_var_str) = last_updated__n {
18580        local_var_req_builder = match "multi" {
18581            "multi" => local_var_req_builder.query(
18582                &local_var_str
18583                    .into_iter()
18584                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
18585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18586            ),
18587            _ => local_var_req_builder.query(&[(
18588                "last_updated__n",
18589                &local_var_str
18590                    .into_iter()
18591                    .map(|p| p.to_string())
18592                    .collect::<Vec<String>>()
18593                    .join(",")
18594                    .to_string(),
18595            )]),
18596        };
18597    }
18598    if let Some(ref local_var_str) = limit {
18599        local_var_req_builder =
18600            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
18601    }
18602    if let Some(ref local_var_str) = location {
18603        local_var_req_builder = match "multi" {
18604            "multi" => local_var_req_builder.query(
18605                &local_var_str
18606                    .into_iter()
18607                    .map(|p| ("location".to_owned(), p.to_string()))
18608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18609            ),
18610            _ => local_var_req_builder.query(&[(
18611                "location",
18612                &local_var_str
18613                    .into_iter()
18614                    .map(|p| p.to_string())
18615                    .collect::<Vec<String>>()
18616                    .join(",")
18617                    .to_string(),
18618            )]),
18619        };
18620    }
18621    if let Some(ref local_var_str) = location__n {
18622        local_var_req_builder = match "multi" {
18623            "multi" => local_var_req_builder.query(
18624                &local_var_str
18625                    .into_iter()
18626                    .map(|p| ("location__n".to_owned(), p.to_string()))
18627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18628            ),
18629            _ => local_var_req_builder.query(&[(
18630                "location__n",
18631                &local_var_str
18632                    .into_iter()
18633                    .map(|p| p.to_string())
18634                    .collect::<Vec<String>>()
18635                    .join(",")
18636                    .to_string(),
18637            )]),
18638        };
18639    }
18640    if let Some(ref local_var_str) = locations {
18641        local_var_req_builder = match "multi" {
18642            "multi" => local_var_req_builder.query(
18643                &local_var_str
18644                    .into_iter()
18645                    .map(|p| ("locations".to_owned(), p.to_string()))
18646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18647            ),
18648            _ => local_var_req_builder.query(&[(
18649                "locations",
18650                &local_var_str
18651                    .into_iter()
18652                    .map(|p| p.to_string())
18653                    .collect::<Vec<String>>()
18654                    .join(",")
18655                    .to_string(),
18656            )]),
18657        };
18658    }
18659    if let Some(ref local_var_str) = locations__n {
18660        local_var_req_builder = match "multi" {
18661            "multi" => local_var_req_builder.query(
18662                &local_var_str
18663                    .into_iter()
18664                    .map(|p| ("locations__n".to_owned(), p.to_string()))
18665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18666            ),
18667            _ => local_var_req_builder.query(&[(
18668                "locations__n",
18669                &local_var_str
18670                    .into_iter()
18671                    .map(|p| p.to_string())
18672                    .collect::<Vec<String>>()
18673                    .join(",")
18674                    .to_string(),
18675            )]),
18676        };
18677    }
18678    if let Some(ref local_var_str) = name {
18679        local_var_req_builder = match "multi" {
18680            "multi" => local_var_req_builder.query(
18681                &local_var_str
18682                    .into_iter()
18683                    .map(|p| ("name".to_owned(), p.to_string()))
18684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18685            ),
18686            _ => local_var_req_builder.query(&[(
18687                "name",
18688                &local_var_str
18689                    .into_iter()
18690                    .map(|p| p.to_string())
18691                    .collect::<Vec<String>>()
18692                    .join(",")
18693                    .to_string(),
18694            )]),
18695        };
18696    }
18697    if let Some(ref local_var_str) = name__ic {
18698        local_var_req_builder = match "multi" {
18699            "multi" => local_var_req_builder.query(
18700                &local_var_str
18701                    .into_iter()
18702                    .map(|p| ("name__ic".to_owned(), p.to_string()))
18703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18704            ),
18705            _ => local_var_req_builder.query(&[(
18706                "name__ic",
18707                &local_var_str
18708                    .into_iter()
18709                    .map(|p| p.to_string())
18710                    .collect::<Vec<String>>()
18711                    .join(",")
18712                    .to_string(),
18713            )]),
18714        };
18715    }
18716    if let Some(ref local_var_str) = name__ie {
18717        local_var_req_builder = match "multi" {
18718            "multi" => local_var_req_builder.query(
18719                &local_var_str
18720                    .into_iter()
18721                    .map(|p| ("name__ie".to_owned(), p.to_string()))
18722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18723            ),
18724            _ => local_var_req_builder.query(&[(
18725                "name__ie",
18726                &local_var_str
18727                    .into_iter()
18728                    .map(|p| p.to_string())
18729                    .collect::<Vec<String>>()
18730                    .join(",")
18731                    .to_string(),
18732            )]),
18733        };
18734    }
18735    if let Some(ref local_var_str) = name__iew {
18736        local_var_req_builder = match "multi" {
18737            "multi" => local_var_req_builder.query(
18738                &local_var_str
18739                    .into_iter()
18740                    .map(|p| ("name__iew".to_owned(), p.to_string()))
18741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18742            ),
18743            _ => local_var_req_builder.query(&[(
18744                "name__iew",
18745                &local_var_str
18746                    .into_iter()
18747                    .map(|p| p.to_string())
18748                    .collect::<Vec<String>>()
18749                    .join(",")
18750                    .to_string(),
18751            )]),
18752        };
18753    }
18754    if let Some(ref local_var_str) = name__ire {
18755        local_var_req_builder = match "multi" {
18756            "multi" => local_var_req_builder.query(
18757                &local_var_str
18758                    .into_iter()
18759                    .map(|p| ("name__ire".to_owned(), p.to_string()))
18760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18761            ),
18762            _ => local_var_req_builder.query(&[(
18763                "name__ire",
18764                &local_var_str
18765                    .into_iter()
18766                    .map(|p| p.to_string())
18767                    .collect::<Vec<String>>()
18768                    .join(",")
18769                    .to_string(),
18770            )]),
18771        };
18772    }
18773    if let Some(ref local_var_str) = name__isw {
18774        local_var_req_builder = match "multi" {
18775            "multi" => local_var_req_builder.query(
18776                &local_var_str
18777                    .into_iter()
18778                    .map(|p| ("name__isw".to_owned(), p.to_string()))
18779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18780            ),
18781            _ => local_var_req_builder.query(&[(
18782                "name__isw",
18783                &local_var_str
18784                    .into_iter()
18785                    .map(|p| p.to_string())
18786                    .collect::<Vec<String>>()
18787                    .join(",")
18788                    .to_string(),
18789            )]),
18790        };
18791    }
18792    if let Some(ref local_var_str) = name__n {
18793        local_var_req_builder = match "multi" {
18794            "multi" => local_var_req_builder.query(
18795                &local_var_str
18796                    .into_iter()
18797                    .map(|p| ("name__n".to_owned(), p.to_string()))
18798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18799            ),
18800            _ => local_var_req_builder.query(&[(
18801                "name__n",
18802                &local_var_str
18803                    .into_iter()
18804                    .map(|p| p.to_string())
18805                    .collect::<Vec<String>>()
18806                    .join(",")
18807                    .to_string(),
18808            )]),
18809        };
18810    }
18811    if let Some(ref local_var_str) = name__nic {
18812        local_var_req_builder = match "multi" {
18813            "multi" => local_var_req_builder.query(
18814                &local_var_str
18815                    .into_iter()
18816                    .map(|p| ("name__nic".to_owned(), p.to_string()))
18817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18818            ),
18819            _ => local_var_req_builder.query(&[(
18820                "name__nic",
18821                &local_var_str
18822                    .into_iter()
18823                    .map(|p| p.to_string())
18824                    .collect::<Vec<String>>()
18825                    .join(",")
18826                    .to_string(),
18827            )]),
18828        };
18829    }
18830    if let Some(ref local_var_str) = name__nie {
18831        local_var_req_builder = match "multi" {
18832            "multi" => local_var_req_builder.query(
18833                &local_var_str
18834                    .into_iter()
18835                    .map(|p| ("name__nie".to_owned(), p.to_string()))
18836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18837            ),
18838            _ => local_var_req_builder.query(&[(
18839                "name__nie",
18840                &local_var_str
18841                    .into_iter()
18842                    .map(|p| p.to_string())
18843                    .collect::<Vec<String>>()
18844                    .join(",")
18845                    .to_string(),
18846            )]),
18847        };
18848    }
18849    if let Some(ref local_var_str) = name__niew {
18850        local_var_req_builder = match "multi" {
18851            "multi" => local_var_req_builder.query(
18852                &local_var_str
18853                    .into_iter()
18854                    .map(|p| ("name__niew".to_owned(), p.to_string()))
18855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18856            ),
18857            _ => local_var_req_builder.query(&[(
18858                "name__niew",
18859                &local_var_str
18860                    .into_iter()
18861                    .map(|p| p.to_string())
18862                    .collect::<Vec<String>>()
18863                    .join(",")
18864                    .to_string(),
18865            )]),
18866        };
18867    }
18868    if let Some(ref local_var_str) = name__nire {
18869        local_var_req_builder = match "multi" {
18870            "multi" => local_var_req_builder.query(
18871                &local_var_str
18872                    .into_iter()
18873                    .map(|p| ("name__nire".to_owned(), p.to_string()))
18874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18875            ),
18876            _ => local_var_req_builder.query(&[(
18877                "name__nire",
18878                &local_var_str
18879                    .into_iter()
18880                    .map(|p| p.to_string())
18881                    .collect::<Vec<String>>()
18882                    .join(",")
18883                    .to_string(),
18884            )]),
18885        };
18886    }
18887    if let Some(ref local_var_str) = name__nisw {
18888        local_var_req_builder = match "multi" {
18889            "multi" => local_var_req_builder.query(
18890                &local_var_str
18891                    .into_iter()
18892                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
18893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18894            ),
18895            _ => local_var_req_builder.query(&[(
18896                "name__nisw",
18897                &local_var_str
18898                    .into_iter()
18899                    .map(|p| p.to_string())
18900                    .collect::<Vec<String>>()
18901                    .join(",")
18902                    .to_string(),
18903            )]),
18904        };
18905    }
18906    if let Some(ref local_var_str) = name__nre {
18907        local_var_req_builder = match "multi" {
18908            "multi" => local_var_req_builder.query(
18909                &local_var_str
18910                    .into_iter()
18911                    .map(|p| ("name__nre".to_owned(), p.to_string()))
18912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18913            ),
18914            _ => local_var_req_builder.query(&[(
18915                "name__nre",
18916                &local_var_str
18917                    .into_iter()
18918                    .map(|p| p.to_string())
18919                    .collect::<Vec<String>>()
18920                    .join(",")
18921                    .to_string(),
18922            )]),
18923        };
18924    }
18925    if let Some(ref local_var_str) = name__re {
18926        local_var_req_builder = match "multi" {
18927            "multi" => local_var_req_builder.query(
18928                &local_var_str
18929                    .into_iter()
18930                    .map(|p| ("name__re".to_owned(), p.to_string()))
18931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18932            ),
18933            _ => local_var_req_builder.query(&[(
18934                "name__re",
18935                &local_var_str
18936                    .into_iter()
18937                    .map(|p| p.to_string())
18938                    .collect::<Vec<String>>()
18939                    .join(",")
18940                    .to_string(),
18941            )]),
18942        };
18943    }
18944    if let Some(ref local_var_str) = offset {
18945        local_var_req_builder =
18946            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
18947    }
18948    if let Some(ref local_var_str) = q {
18949        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
18950    }
18951    if let Some(ref local_var_str) = role {
18952        local_var_req_builder = match "multi" {
18953            "multi" => local_var_req_builder.query(
18954                &local_var_str
18955                    .into_iter()
18956                    .map(|p| ("role".to_owned(), p.to_string()))
18957                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18958            ),
18959            _ => local_var_req_builder.query(&[(
18960                "role",
18961                &local_var_str
18962                    .into_iter()
18963                    .map(|p| p.to_string())
18964                    .collect::<Vec<String>>()
18965                    .join(",")
18966                    .to_string(),
18967            )]),
18968        };
18969    }
18970    if let Some(ref local_var_str) = role__isnull {
18971        local_var_req_builder =
18972            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
18973    }
18974    if let Some(ref local_var_str) = role__n {
18975        local_var_req_builder = match "multi" {
18976            "multi" => local_var_req_builder.query(
18977                &local_var_str
18978                    .into_iter()
18979                    .map(|p| ("role__n".to_owned(), p.to_string()))
18980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18981            ),
18982            _ => local_var_req_builder.query(&[(
18983                "role__n",
18984                &local_var_str
18985                    .into_iter()
18986                    .map(|p| p.to_string())
18987                    .collect::<Vec<String>>()
18988                    .join(",")
18989                    .to_string(),
18990            )]),
18991        };
18992    }
18993    if let Some(ref local_var_str) = sort {
18994        local_var_req_builder =
18995            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
18996    }
18997    if let Some(ref local_var_str) = status {
18998        local_var_req_builder = match "multi" {
18999            "multi" => local_var_req_builder.query(
19000                &local_var_str
19001                    .into_iter()
19002                    .map(|p| ("status".to_owned(), p.to_string()))
19003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19004            ),
19005            _ => local_var_req_builder.query(&[(
19006                "status",
19007                &local_var_str
19008                    .into_iter()
19009                    .map(|p| p.to_string())
19010                    .collect::<Vec<String>>()
19011                    .join(",")
19012                    .to_string(),
19013            )]),
19014        };
19015    }
19016    if let Some(ref local_var_str) = status__n {
19017        local_var_req_builder = match "multi" {
19018            "multi" => local_var_req_builder.query(
19019                &local_var_str
19020                    .into_iter()
19021                    .map(|p| ("status__n".to_owned(), p.to_string()))
19022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19023            ),
19024            _ => local_var_req_builder.query(&[(
19025                "status__n",
19026                &local_var_str
19027                    .into_iter()
19028                    .map(|p| p.to_string())
19029                    .collect::<Vec<String>>()
19030                    .join(",")
19031                    .to_string(),
19032            )]),
19033        };
19034    }
19035    if let Some(ref local_var_str) = tags {
19036        local_var_req_builder = match "multi" {
19037            "multi" => local_var_req_builder.query(
19038                &local_var_str
19039                    .into_iter()
19040                    .map(|p| ("tags".to_owned(), p.to_string()))
19041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19042            ),
19043            _ => local_var_req_builder.query(&[(
19044                "tags",
19045                &local_var_str
19046                    .into_iter()
19047                    .map(|p| p.to_string())
19048                    .collect::<Vec<String>>()
19049                    .join(",")
19050                    .to_string(),
19051            )]),
19052        };
19053    }
19054    if let Some(ref local_var_str) = tags__isnull {
19055        local_var_req_builder =
19056            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
19057    }
19058    if let Some(ref local_var_str) = tags__n {
19059        local_var_req_builder = match "multi" {
19060            "multi" => local_var_req_builder.query(
19061                &local_var_str
19062                    .into_iter()
19063                    .map(|p| ("tags__n".to_owned(), p.to_string()))
19064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19065            ),
19066            _ => local_var_req_builder.query(&[(
19067                "tags__n",
19068                &local_var_str
19069                    .into_iter()
19070                    .map(|p| p.to_string())
19071                    .collect::<Vec<String>>()
19072                    .join(",")
19073                    .to_string(),
19074            )]),
19075        };
19076    }
19077    if let Some(ref local_var_str) = teams {
19078        local_var_req_builder = match "multi" {
19079            "multi" => local_var_req_builder.query(
19080                &local_var_str
19081                    .into_iter()
19082                    .map(|p| ("teams".to_owned(), p.to_string()))
19083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19084            ),
19085            _ => local_var_req_builder.query(&[(
19086                "teams",
19087                &local_var_str
19088                    .into_iter()
19089                    .map(|p| p.to_string())
19090                    .collect::<Vec<String>>()
19091                    .join(",")
19092                    .to_string(),
19093            )]),
19094        };
19095    }
19096    if let Some(ref local_var_str) = teams__isnull {
19097        local_var_req_builder =
19098            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
19099    }
19100    if let Some(ref local_var_str) = teams__n {
19101        local_var_req_builder = match "multi" {
19102            "multi" => local_var_req_builder.query(
19103                &local_var_str
19104                    .into_iter()
19105                    .map(|p| ("teams__n".to_owned(), p.to_string()))
19106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19107            ),
19108            _ => local_var_req_builder.query(&[(
19109                "teams__n",
19110                &local_var_str
19111                    .into_iter()
19112                    .map(|p| p.to_string())
19113                    .collect::<Vec<String>>()
19114                    .join(",")
19115                    .to_string(),
19116            )]),
19117        };
19118    }
19119    if let Some(ref local_var_str) = tenant {
19120        local_var_req_builder = match "multi" {
19121            "multi" => local_var_req_builder.query(
19122                &local_var_str
19123                    .into_iter()
19124                    .map(|p| ("tenant".to_owned(), p.to_string()))
19125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19126            ),
19127            _ => local_var_req_builder.query(&[(
19128                "tenant",
19129                &local_var_str
19130                    .into_iter()
19131                    .map(|p| p.to_string())
19132                    .collect::<Vec<String>>()
19133                    .join(",")
19134                    .to_string(),
19135            )]),
19136        };
19137    }
19138    if let Some(ref local_var_str) = tenant__isnull {
19139        local_var_req_builder =
19140            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
19141    }
19142    if let Some(ref local_var_str) = tenant__n {
19143        local_var_req_builder = match "multi" {
19144            "multi" => local_var_req_builder.query(
19145                &local_var_str
19146                    .into_iter()
19147                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
19148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19149            ),
19150            _ => local_var_req_builder.query(&[(
19151                "tenant__n",
19152                &local_var_str
19153                    .into_iter()
19154                    .map(|p| p.to_string())
19155                    .collect::<Vec<String>>()
19156                    .join(",")
19157                    .to_string(),
19158            )]),
19159        };
19160    }
19161    if let Some(ref local_var_str) = tenant_group {
19162        local_var_req_builder = match "multi" {
19163            "multi" => local_var_req_builder.query(
19164                &local_var_str
19165                    .into_iter()
19166                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
19167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19168            ),
19169            _ => local_var_req_builder.query(&[(
19170                "tenant_group",
19171                &local_var_str
19172                    .into_iter()
19173                    .map(|p| p.to_string())
19174                    .collect::<Vec<String>>()
19175                    .join(",")
19176                    .to_string(),
19177            )]),
19178        };
19179    }
19180    if let Some(ref local_var_str) = tenant_group__isnull {
19181        local_var_req_builder =
19182            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
19183    }
19184    if let Some(ref local_var_str) = tenant_group__n {
19185        local_var_req_builder = match "multi" {
19186            "multi" => local_var_req_builder.query(
19187                &local_var_str
19188                    .into_iter()
19189                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
19190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19191            ),
19192            _ => local_var_req_builder.query(&[(
19193                "tenant_group__n",
19194                &local_var_str
19195                    .into_iter()
19196                    .map(|p| p.to_string())
19197                    .collect::<Vec<String>>()
19198                    .join(",")
19199                    .to_string(),
19200            )]),
19201        };
19202    }
19203    if let Some(ref local_var_str) = tenant_id {
19204        local_var_req_builder = match "multi" {
19205            "multi" => local_var_req_builder.query(
19206                &local_var_str
19207                    .into_iter()
19208                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
19209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19210            ),
19211            _ => local_var_req_builder.query(&[(
19212                "tenant_id",
19213                &local_var_str
19214                    .into_iter()
19215                    .map(|p| p.to_string())
19216                    .collect::<Vec<String>>()
19217                    .join(",")
19218                    .to_string(),
19219            )]),
19220        };
19221    }
19222    if let Some(ref local_var_str) = tenant_id__isnull {
19223        local_var_req_builder =
19224            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
19225    }
19226    if let Some(ref local_var_str) = tenant_id__n {
19227        local_var_req_builder = match "multi" {
19228            "multi" => local_var_req_builder.query(
19229                &local_var_str
19230                    .into_iter()
19231                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
19232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19233            ),
19234            _ => local_var_req_builder.query(&[(
19235                "tenant_id__n",
19236                &local_var_str
19237                    .into_iter()
19238                    .map(|p| p.to_string())
19239                    .collect::<Vec<String>>()
19240                    .join(",")
19241                    .to_string(),
19242            )]),
19243        };
19244    }
19245    if let Some(ref local_var_str) = vid {
19246        local_var_req_builder = match "multi" {
19247            "multi" => local_var_req_builder.query(
19248                &local_var_str
19249                    .into_iter()
19250                    .map(|p| ("vid".to_owned(), p.to_string()))
19251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19252            ),
19253            _ => local_var_req_builder.query(&[(
19254                "vid",
19255                &local_var_str
19256                    .into_iter()
19257                    .map(|p| p.to_string())
19258                    .collect::<Vec<String>>()
19259                    .join(",")
19260                    .to_string(),
19261            )]),
19262        };
19263    }
19264    if let Some(ref local_var_str) = vid__gt {
19265        local_var_req_builder = match "multi" {
19266            "multi" => local_var_req_builder.query(
19267                &local_var_str
19268                    .into_iter()
19269                    .map(|p| ("vid__gt".to_owned(), p.to_string()))
19270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19271            ),
19272            _ => local_var_req_builder.query(&[(
19273                "vid__gt",
19274                &local_var_str
19275                    .into_iter()
19276                    .map(|p| p.to_string())
19277                    .collect::<Vec<String>>()
19278                    .join(",")
19279                    .to_string(),
19280            )]),
19281        };
19282    }
19283    if let Some(ref local_var_str) = vid__gte {
19284        local_var_req_builder = match "multi" {
19285            "multi" => local_var_req_builder.query(
19286                &local_var_str
19287                    .into_iter()
19288                    .map(|p| ("vid__gte".to_owned(), p.to_string()))
19289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19290            ),
19291            _ => local_var_req_builder.query(&[(
19292                "vid__gte",
19293                &local_var_str
19294                    .into_iter()
19295                    .map(|p| p.to_string())
19296                    .collect::<Vec<String>>()
19297                    .join(",")
19298                    .to_string(),
19299            )]),
19300        };
19301    }
19302    if let Some(ref local_var_str) = vid__lt {
19303        local_var_req_builder = match "multi" {
19304            "multi" => local_var_req_builder.query(
19305                &local_var_str
19306                    .into_iter()
19307                    .map(|p| ("vid__lt".to_owned(), p.to_string()))
19308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19309            ),
19310            _ => local_var_req_builder.query(&[(
19311                "vid__lt",
19312                &local_var_str
19313                    .into_iter()
19314                    .map(|p| p.to_string())
19315                    .collect::<Vec<String>>()
19316                    .join(",")
19317                    .to_string(),
19318            )]),
19319        };
19320    }
19321    if let Some(ref local_var_str) = vid__lte {
19322        local_var_req_builder = match "multi" {
19323            "multi" => local_var_req_builder.query(
19324                &local_var_str
19325                    .into_iter()
19326                    .map(|p| ("vid__lte".to_owned(), p.to_string()))
19327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19328            ),
19329            _ => local_var_req_builder.query(&[(
19330                "vid__lte",
19331                &local_var_str
19332                    .into_iter()
19333                    .map(|p| p.to_string())
19334                    .collect::<Vec<String>>()
19335                    .join(",")
19336                    .to_string(),
19337            )]),
19338        };
19339    }
19340    if let Some(ref local_var_str) = vid__n {
19341        local_var_req_builder = match "multi" {
19342            "multi" => local_var_req_builder.query(
19343                &local_var_str
19344                    .into_iter()
19345                    .map(|p| ("vid__n".to_owned(), p.to_string()))
19346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19347            ),
19348            _ => local_var_req_builder.query(&[(
19349                "vid__n",
19350                &local_var_str
19351                    .into_iter()
19352                    .map(|p| p.to_string())
19353                    .collect::<Vec<String>>()
19354                    .join(",")
19355                    .to_string(),
19356            )]),
19357        };
19358    }
19359    if let Some(ref local_var_str) = vlan_group {
19360        local_var_req_builder = match "multi" {
19361            "multi" => local_var_req_builder.query(
19362                &local_var_str
19363                    .into_iter()
19364                    .map(|p| ("vlan_group".to_owned(), p.to_string()))
19365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19366            ),
19367            _ => local_var_req_builder.query(&[(
19368                "vlan_group",
19369                &local_var_str
19370                    .into_iter()
19371                    .map(|p| p.to_string())
19372                    .collect::<Vec<String>>()
19373                    .join(",")
19374                    .to_string(),
19375            )]),
19376        };
19377    }
19378    if let Some(ref local_var_str) = vlan_group__isnull {
19379        local_var_req_builder =
19380            local_var_req_builder.query(&[("vlan_group__isnull", &local_var_str.to_string())]);
19381    }
19382    if let Some(ref local_var_str) = vlan_group__n {
19383        local_var_req_builder = match "multi" {
19384            "multi" => local_var_req_builder.query(
19385                &local_var_str
19386                    .into_iter()
19387                    .map(|p| ("vlan_group__n".to_owned(), p.to_string()))
19388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19389            ),
19390            _ => local_var_req_builder.query(&[(
19391                "vlan_group__n",
19392                &local_var_str
19393                    .into_iter()
19394                    .map(|p| p.to_string())
19395                    .collect::<Vec<String>>()
19396                    .join(",")
19397                    .to_string(),
19398            )]),
19399        };
19400    }
19401    if let Some(ref local_var_str) = depth {
19402        local_var_req_builder =
19403            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
19404    }
19405    if let Some(ref local_var_str) = exclude_m2m {
19406        local_var_req_builder =
19407            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
19408    }
19409    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19410        local_var_req_builder =
19411            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19412    }
19413    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19414        let local_var_key = local_var_apikey.key.clone();
19415        let local_var_value = match local_var_apikey.prefix {
19416            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19417            None => local_var_key,
19418        };
19419        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19420    };
19421
19422    let local_var_req = local_var_req_builder.build()?;
19423    let local_var_resp = local_var_client.execute(local_var_req).await?;
19424
19425    let local_var_status = local_var_resp.status();
19426    let local_var_content = local_var_resp.text().await?;
19427
19428    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19429        serde_json::from_str(&local_var_content).map_err(Error::from)
19430    } else {
19431        let local_var_entity: Option<IpamVlansListError> =
19432            serde_json::from_str(&local_var_content).ok();
19433        let local_var_error = ResponseContent {
19434            status: local_var_status,
19435            content: local_var_content,
19436            entity: local_var_entity,
19437        };
19438        Err(Error::ResponseError(local_var_error))
19439    }
19440}
19441
19442/// API methods for returning or creating notes on an object.
19443pub async fn ipam_vlans_notes_create(
19444    configuration: &configuration::Configuration,
19445    id: &str,
19446    note_input_request: crate::models::NoteInputRequest,
19447    format: Option<&str>,
19448) -> Result<crate::models::Note, Error<IpamVlansNotesCreateError>> {
19449    let local_var_configuration = configuration;
19450
19451    let local_var_client = &local_var_configuration.client;
19452
19453    let local_var_uri_str = format!(
19454        "{}/ipam/vlans/{id}/notes/",
19455        local_var_configuration.base_path,
19456        id = crate::apis::urlencode(id)
19457    );
19458    let mut local_var_req_builder =
19459        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
19460
19461    if let Some(ref local_var_str) = format {
19462        local_var_req_builder =
19463            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19464    }
19465    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19466        local_var_req_builder =
19467            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19468    }
19469    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19470        let local_var_key = local_var_apikey.key.clone();
19471        let local_var_value = match local_var_apikey.prefix {
19472            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19473            None => local_var_key,
19474        };
19475        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19476    };
19477    local_var_req_builder = local_var_req_builder.json(&note_input_request);
19478
19479    let local_var_req = local_var_req_builder.build()?;
19480    let local_var_resp = local_var_client.execute(local_var_req).await?;
19481
19482    let local_var_status = local_var_resp.status();
19483    let local_var_content = local_var_resp.text().await?;
19484
19485    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19486        serde_json::from_str(&local_var_content).map_err(Error::from)
19487    } else {
19488        let local_var_entity: Option<IpamVlansNotesCreateError> =
19489            serde_json::from_str(&local_var_content).ok();
19490        let local_var_error = ResponseContent {
19491            status: local_var_status,
19492            content: local_var_content,
19493            entity: local_var_entity,
19494        };
19495        Err(Error::ResponseError(local_var_error))
19496    }
19497}
19498
19499/// API methods for returning or creating notes on an object.
19500pub async fn ipam_vlans_notes_list(
19501    configuration: &configuration::Configuration,
19502    id: &str,
19503    format: Option<&str>,
19504    limit: Option<i32>,
19505    offset: Option<i32>,
19506    depth: Option<i32>,
19507    exclude_m2m: Option<bool>,
19508) -> Result<crate::models::PaginatedNoteList, Error<IpamVlansNotesListError>> {
19509    let local_var_configuration = configuration;
19510
19511    let local_var_client = &local_var_configuration.client;
19512
19513    let local_var_uri_str = format!(
19514        "{}/ipam/vlans/{id}/notes/",
19515        local_var_configuration.base_path,
19516        id = crate::apis::urlencode(id)
19517    );
19518    let mut local_var_req_builder =
19519        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19520
19521    if let Some(ref local_var_str) = format {
19522        local_var_req_builder =
19523            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19524    }
19525    if let Some(ref local_var_str) = limit {
19526        local_var_req_builder =
19527            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
19528    }
19529    if let Some(ref local_var_str) = offset {
19530        local_var_req_builder =
19531            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
19532    }
19533    if let Some(ref local_var_str) = depth {
19534        local_var_req_builder =
19535            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
19536    }
19537    if let Some(ref local_var_str) = exclude_m2m {
19538        local_var_req_builder =
19539            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
19540    }
19541    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19542        local_var_req_builder =
19543            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19544    }
19545    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19546        let local_var_key = local_var_apikey.key.clone();
19547        let local_var_value = match local_var_apikey.prefix {
19548            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19549            None => local_var_key,
19550        };
19551        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19552    };
19553
19554    let local_var_req = local_var_req_builder.build()?;
19555    let local_var_resp = local_var_client.execute(local_var_req).await?;
19556
19557    let local_var_status = local_var_resp.status();
19558    let local_var_content = local_var_resp.text().await?;
19559
19560    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19561        serde_json::from_str(&local_var_content).map_err(Error::from)
19562    } else {
19563        let local_var_entity: Option<IpamVlansNotesListError> =
19564            serde_json::from_str(&local_var_content).ok();
19565        let local_var_error = ResponseContent {
19566            status: local_var_status,
19567            content: local_var_content,
19568            entity: local_var_entity,
19569        };
19570        Err(Error::ResponseError(local_var_error))
19571    }
19572}
19573
19574/// Partial update a VLAN object.
19575pub async fn ipam_vlans_partial_update(
19576    configuration: &configuration::Configuration,
19577    id: &str,
19578    format: Option<&str>,
19579    patched_vlan_request: Option<crate::models::PatchedVlanRequest>,
19580) -> Result<crate::models::Vlan, Error<IpamVlansPartialUpdateError>> {
19581    let local_var_configuration = configuration;
19582
19583    let local_var_client = &local_var_configuration.client;
19584
19585    let local_var_uri_str = format!(
19586        "{}/ipam/vlans/{id}/",
19587        local_var_configuration.base_path,
19588        id = crate::apis::urlencode(id)
19589    );
19590    let mut local_var_req_builder =
19591        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19592
19593    if let Some(ref local_var_str) = format {
19594        local_var_req_builder =
19595            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19596    }
19597    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19598        local_var_req_builder =
19599            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19600    }
19601    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19602        let local_var_key = local_var_apikey.key.clone();
19603        let local_var_value = match local_var_apikey.prefix {
19604            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19605            None => local_var_key,
19606        };
19607        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19608    };
19609    local_var_req_builder = local_var_req_builder.json(&patched_vlan_request);
19610
19611    let local_var_req = local_var_req_builder.build()?;
19612    let local_var_resp = local_var_client.execute(local_var_req).await?;
19613
19614    let local_var_status = local_var_resp.status();
19615    let local_var_content = local_var_resp.text().await?;
19616
19617    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19618        serde_json::from_str(&local_var_content).map_err(Error::from)
19619    } else {
19620        let local_var_entity: Option<IpamVlansPartialUpdateError> =
19621            serde_json::from_str(&local_var_content).ok();
19622        let local_var_error = ResponseContent {
19623            status: local_var_status,
19624            content: local_var_content,
19625            entity: local_var_entity,
19626        };
19627        Err(Error::ResponseError(local_var_error))
19628    }
19629}
19630
19631/// Retrieve a VLAN object.
19632pub async fn ipam_vlans_retrieve(
19633    configuration: &configuration::Configuration,
19634    id: &str,
19635    format: Option<&str>,
19636    depth: Option<i32>,
19637    exclude_m2m: Option<bool>,
19638) -> Result<crate::models::Vlan, Error<IpamVlansRetrieveError>> {
19639    let local_var_configuration = configuration;
19640
19641    let local_var_client = &local_var_configuration.client;
19642
19643    let local_var_uri_str = format!(
19644        "{}/ipam/vlans/{id}/",
19645        local_var_configuration.base_path,
19646        id = crate::apis::urlencode(id)
19647    );
19648    let mut local_var_req_builder =
19649        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19650
19651    if let Some(ref local_var_str) = format {
19652        local_var_req_builder =
19653            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19654    }
19655    if let Some(ref local_var_str) = depth {
19656        local_var_req_builder =
19657            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
19658    }
19659    if let Some(ref local_var_str) = exclude_m2m {
19660        local_var_req_builder =
19661            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
19662    }
19663    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19664        local_var_req_builder =
19665            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19666    }
19667    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19668        let local_var_key = local_var_apikey.key.clone();
19669        let local_var_value = match local_var_apikey.prefix {
19670            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19671            None => local_var_key,
19672        };
19673        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19674    };
19675
19676    let local_var_req = local_var_req_builder.build()?;
19677    let local_var_resp = local_var_client.execute(local_var_req).await?;
19678
19679    let local_var_status = local_var_resp.status();
19680    let local_var_content = local_var_resp.text().await?;
19681
19682    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19683        serde_json::from_str(&local_var_content).map_err(Error::from)
19684    } else {
19685        let local_var_entity: Option<IpamVlansRetrieveError> =
19686            serde_json::from_str(&local_var_content).ok();
19687        let local_var_error = ResponseContent {
19688            status: local_var_status,
19689            content: local_var_content,
19690            entity: local_var_entity,
19691        };
19692        Err(Error::ResponseError(local_var_error))
19693    }
19694}
19695
19696/// Update a VLAN object.
19697pub async fn ipam_vlans_update(
19698    configuration: &configuration::Configuration,
19699    id: &str,
19700    vlan_request: crate::models::VlanRequest,
19701    format: Option<&str>,
19702) -> Result<crate::models::Vlan, Error<IpamVlansUpdateError>> {
19703    let local_var_configuration = configuration;
19704
19705    let local_var_client = &local_var_configuration.client;
19706
19707    let local_var_uri_str = format!(
19708        "{}/ipam/vlans/{id}/",
19709        local_var_configuration.base_path,
19710        id = crate::apis::urlencode(id)
19711    );
19712    let mut local_var_req_builder =
19713        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19714
19715    if let Some(ref local_var_str) = format {
19716        local_var_req_builder =
19717            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19718    }
19719    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19720        local_var_req_builder =
19721            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19722    }
19723    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19724        let local_var_key = local_var_apikey.key.clone();
19725        let local_var_value = match local_var_apikey.prefix {
19726            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19727            None => local_var_key,
19728        };
19729        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19730    };
19731    local_var_req_builder = local_var_req_builder.json(&vlan_request);
19732
19733    let local_var_req = local_var_req_builder.build()?;
19734    let local_var_resp = local_var_client.execute(local_var_req).await?;
19735
19736    let local_var_status = local_var_resp.status();
19737    let local_var_content = local_var_resp.text().await?;
19738
19739    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19740        serde_json::from_str(&local_var_content).map_err(Error::from)
19741    } else {
19742        let local_var_entity: Option<IpamVlansUpdateError> =
19743            serde_json::from_str(&local_var_content).ok();
19744        let local_var_error = ResponseContent {
19745            status: local_var_status,
19746            content: local_var_content,
19747            entity: local_var_entity,
19748        };
19749        Err(Error::ResponseError(local_var_error))
19750    }
19751}
19752
19753/// Destroy a list of VRF-device assignment objects.
19754pub async fn ipam_vrf_device_assignments_bulk_destroy(
19755    configuration: &configuration::Configuration,
19756    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
19757    format: Option<&str>,
19758) -> Result<(), Error<IpamVrfDeviceAssignmentsBulkDestroyError>> {
19759    let local_var_configuration = configuration;
19760
19761    let local_var_client = &local_var_configuration.client;
19762
19763    let local_var_uri_str = format!(
19764        "{}/ipam/vrf-device-assignments/",
19765        local_var_configuration.base_path
19766    );
19767    let mut local_var_req_builder =
19768        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19769
19770    if let Some(ref local_var_str) = format {
19771        local_var_req_builder =
19772            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19773    }
19774    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19775        local_var_req_builder =
19776            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19777    }
19778    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19779        let local_var_key = local_var_apikey.key.clone();
19780        let local_var_value = match local_var_apikey.prefix {
19781            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19782            None => local_var_key,
19783        };
19784        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19785    };
19786    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
19787
19788    let local_var_req = local_var_req_builder.build()?;
19789    let local_var_resp = local_var_client.execute(local_var_req).await?;
19790
19791    let local_var_status = local_var_resp.status();
19792    let local_var_content = local_var_resp.text().await?;
19793
19794    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19795        Ok(())
19796    } else {
19797        let local_var_entity: Option<IpamVrfDeviceAssignmentsBulkDestroyError> =
19798            serde_json::from_str(&local_var_content).ok();
19799        let local_var_error = ResponseContent {
19800            status: local_var_status,
19801            content: local_var_content,
19802            entity: local_var_entity,
19803        };
19804        Err(Error::ResponseError(local_var_error))
19805    }
19806}
19807
19808/// Partial update a list of VRF-device assignment objects.
19809pub async fn ipam_vrf_device_assignments_bulk_partial_update(
19810    configuration: &configuration::Configuration,
19811    patched_bulk_writable_vrf_device_assignment_request: Vec<
19812        crate::models::PatchedBulkWritableVrfDeviceAssignmentRequest,
19813    >,
19814    format: Option<&str>,
19815) -> Result<
19816    Vec<crate::models::VrfDeviceAssignment>,
19817    Error<IpamVrfDeviceAssignmentsBulkPartialUpdateError>,
19818> {
19819    let local_var_configuration = configuration;
19820
19821    let local_var_client = &local_var_configuration.client;
19822
19823    let local_var_uri_str = format!(
19824        "{}/ipam/vrf-device-assignments/",
19825        local_var_configuration.base_path
19826    );
19827    let mut local_var_req_builder =
19828        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19829
19830    if let Some(ref local_var_str) = format {
19831        local_var_req_builder =
19832            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19833    }
19834    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19835        local_var_req_builder =
19836            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19837    }
19838    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19839        let local_var_key = local_var_apikey.key.clone();
19840        let local_var_value = match local_var_apikey.prefix {
19841            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19842            None => local_var_key,
19843        };
19844        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19845    };
19846    local_var_req_builder =
19847        local_var_req_builder.json(&patched_bulk_writable_vrf_device_assignment_request);
19848
19849    let local_var_req = local_var_req_builder.build()?;
19850    let local_var_resp = local_var_client.execute(local_var_req).await?;
19851
19852    let local_var_status = local_var_resp.status();
19853    let local_var_content = local_var_resp.text().await?;
19854
19855    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19856        serde_json::from_str(&local_var_content).map_err(Error::from)
19857    } else {
19858        let local_var_entity: Option<IpamVrfDeviceAssignmentsBulkPartialUpdateError> =
19859            serde_json::from_str(&local_var_content).ok();
19860        let local_var_error = ResponseContent {
19861            status: local_var_status,
19862            content: local_var_content,
19863            entity: local_var_entity,
19864        };
19865        Err(Error::ResponseError(local_var_error))
19866    }
19867}
19868
19869/// Update a list of VRF-device assignment objects.
19870pub async fn ipam_vrf_device_assignments_bulk_update(
19871    configuration: &configuration::Configuration,
19872    bulk_writable_vrf_device_assignment_request: Vec<
19873        crate::models::BulkWritableVrfDeviceAssignmentRequest,
19874    >,
19875    format: Option<&str>,
19876) -> Result<Vec<crate::models::VrfDeviceAssignment>, Error<IpamVrfDeviceAssignmentsBulkUpdateError>>
19877{
19878    let local_var_configuration = configuration;
19879
19880    let local_var_client = &local_var_configuration.client;
19881
19882    let local_var_uri_str = format!(
19883        "{}/ipam/vrf-device-assignments/",
19884        local_var_configuration.base_path
19885    );
19886    let mut local_var_req_builder =
19887        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19888
19889    if let Some(ref local_var_str) = format {
19890        local_var_req_builder =
19891            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19892    }
19893    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19894        local_var_req_builder =
19895            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19896    }
19897    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19898        let local_var_key = local_var_apikey.key.clone();
19899        let local_var_value = match local_var_apikey.prefix {
19900            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19901            None => local_var_key,
19902        };
19903        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19904    };
19905    local_var_req_builder =
19906        local_var_req_builder.json(&bulk_writable_vrf_device_assignment_request);
19907
19908    let local_var_req = local_var_req_builder.build()?;
19909    let local_var_resp = local_var_client.execute(local_var_req).await?;
19910
19911    let local_var_status = local_var_resp.status();
19912    let local_var_content = local_var_resp.text().await?;
19913
19914    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19915        serde_json::from_str(&local_var_content).map_err(Error::from)
19916    } else {
19917        let local_var_entity: Option<IpamVrfDeviceAssignmentsBulkUpdateError> =
19918            serde_json::from_str(&local_var_content).ok();
19919        let local_var_error = ResponseContent {
19920            status: local_var_status,
19921            content: local_var_content,
19922            entity: local_var_entity,
19923        };
19924        Err(Error::ResponseError(local_var_error))
19925    }
19926}
19927
19928/// Create one or more VRF-device assignment objects.
19929pub async fn ipam_vrf_device_assignments_create(
19930    configuration: &configuration::Configuration,
19931    vrf_device_assignment_request: crate::models::VrfDeviceAssignmentRequest,
19932    format: Option<&str>,
19933) -> Result<crate::models::VrfDeviceAssignment, Error<IpamVrfDeviceAssignmentsCreateError>> {
19934    let local_var_configuration = configuration;
19935
19936    let local_var_client = &local_var_configuration.client;
19937
19938    let local_var_uri_str = format!(
19939        "{}/ipam/vrf-device-assignments/",
19940        local_var_configuration.base_path
19941    );
19942    let mut local_var_req_builder =
19943        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
19944
19945    if let Some(ref local_var_str) = format {
19946        local_var_req_builder =
19947            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
19948    }
19949    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19950        local_var_req_builder =
19951            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19952    }
19953    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19954        let local_var_key = local_var_apikey.key.clone();
19955        let local_var_value = match local_var_apikey.prefix {
19956            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19957            None => local_var_key,
19958        };
19959        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19960    };
19961    local_var_req_builder = local_var_req_builder.json(&vrf_device_assignment_request);
19962
19963    let local_var_req = local_var_req_builder.build()?;
19964    let local_var_resp = local_var_client.execute(local_var_req).await?;
19965
19966    let local_var_status = local_var_resp.status();
19967    let local_var_content = local_var_resp.text().await?;
19968
19969    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19970        serde_json::from_str(&local_var_content).map_err(Error::from)
19971    } else {
19972        let local_var_entity: Option<IpamVrfDeviceAssignmentsCreateError> =
19973            serde_json::from_str(&local_var_content).ok();
19974        let local_var_error = ResponseContent {
19975            status: local_var_status,
19976            content: local_var_content,
19977            entity: local_var_entity,
19978        };
19979        Err(Error::ResponseError(local_var_error))
19980    }
19981}
19982
19983/// Destroy a VRF-device assignment object.
19984pub async fn ipam_vrf_device_assignments_destroy(
19985    configuration: &configuration::Configuration,
19986    id: &str,
19987    format: Option<&str>,
19988) -> Result<(), Error<IpamVrfDeviceAssignmentsDestroyError>> {
19989    let local_var_configuration = configuration;
19990
19991    let local_var_client = &local_var_configuration.client;
19992
19993    let local_var_uri_str = format!(
19994        "{}/ipam/vrf-device-assignments/{id}/",
19995        local_var_configuration.base_path,
19996        id = crate::apis::urlencode(id)
19997    );
19998    let mut local_var_req_builder =
19999        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
20000
20001    if let Some(ref local_var_str) = format {
20002        local_var_req_builder =
20003            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
20004    }
20005    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20006        local_var_req_builder =
20007            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20008    }
20009    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20010        let local_var_key = local_var_apikey.key.clone();
20011        let local_var_value = match local_var_apikey.prefix {
20012            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20013            None => local_var_key,
20014        };
20015        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20016    };
20017
20018    let local_var_req = local_var_req_builder.build()?;
20019    let local_var_resp = local_var_client.execute(local_var_req).await?;
20020
20021    let local_var_status = local_var_resp.status();
20022    let local_var_content = local_var_resp.text().await?;
20023
20024    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20025        Ok(())
20026    } else {
20027        let local_var_entity: Option<IpamVrfDeviceAssignmentsDestroyError> =
20028            serde_json::from_str(&local_var_content).ok();
20029        let local_var_error = ResponseContent {
20030            status: local_var_status,
20031            content: local_var_content,
20032            entity: local_var_entity,
20033        };
20034        Err(Error::ResponseError(local_var_error))
20035    }
20036}
20037
20038/// Retrieve a list of VRF-device assignment objects.
20039pub async fn ipam_vrf_device_assignments_list(
20040    configuration: &configuration::Configuration,
20041    created: Option<Vec<String>>,
20042    device: Option<Vec<String>>,
20043    device__isnull: Option<bool>,
20044    device__n: Option<Vec<String>>,
20045    format: Option<&str>,
20046    id: Option<Vec<uuid::Uuid>>,
20047    id__n: Option<Vec<uuid::Uuid>>,
20048    last_updated: Option<Vec<String>>,
20049    limit: Option<i32>,
20050    name: Option<Vec<String>>,
20051    name__ic: Option<Vec<String>>,
20052    name__ie: Option<Vec<String>>,
20053    name__iew: Option<Vec<String>>,
20054    name__ire: Option<Vec<String>>,
20055    name__isw: Option<Vec<String>>,
20056    name__n: Option<Vec<String>>,
20057    name__nic: Option<Vec<String>>,
20058    name__nie: Option<Vec<String>>,
20059    name__niew: Option<Vec<String>>,
20060    name__nire: Option<Vec<String>>,
20061    name__nisw: Option<Vec<String>>,
20062    name__nre: Option<Vec<String>>,
20063    name__re: Option<Vec<String>>,
20064    offset: Option<i32>,
20065    q: Option<&str>,
20066    rd: Option<Vec<String>>,
20067    rd__ic: Option<Vec<String>>,
20068    rd__ie: Option<Vec<String>>,
20069    rd__iew: Option<Vec<String>>,
20070    rd__ire: Option<Vec<String>>,
20071    rd__isnull: Option<bool>,
20072    rd__isw: Option<Vec<String>>,
20073    rd__n: Option<Vec<String>>,
20074    rd__nic: Option<Vec<String>>,
20075    rd__nie: Option<Vec<String>>,
20076    rd__niew: Option<Vec<String>>,
20077    rd__nire: Option<Vec<String>>,
20078    rd__nisw: Option<Vec<String>>,
20079    rd__nre: Option<Vec<String>>,
20080    rd__re: Option<Vec<String>>,
20081    sort: Option<&str>,
20082    virtual_device_context: Option<Vec<String>>,
20083    virtual_device_context__isnull: Option<bool>,
20084    virtual_device_context__n: Option<Vec<String>>,
20085    virtual_machine: Option<Vec<String>>,
20086    virtual_machine__isnull: Option<bool>,
20087    virtual_machine__n: Option<Vec<String>>,
20088    vrf: Option<Vec<String>>,
20089    vrf__n: Option<Vec<String>>,
20090    depth: Option<i32>,
20091    exclude_m2m: Option<bool>,
20092) -> Result<crate::models::PaginatedVrfDeviceAssignmentList, Error<IpamVrfDeviceAssignmentsListError>>
20093{
20094    let local_var_configuration = configuration;
20095
20096    let local_var_client = &local_var_configuration.client;
20097
20098    let local_var_uri_str = format!(
20099        "{}/ipam/vrf-device-assignments/",
20100        local_var_configuration.base_path
20101    );
20102    let mut local_var_req_builder =
20103        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
20104
20105    if let Some(ref local_var_str) = created {
20106        local_var_req_builder = match "multi" {
20107            "multi" => local_var_req_builder.query(
20108                &local_var_str
20109                    .into_iter()
20110                    .map(|p| ("created".to_owned(), p.to_string()))
20111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20112            ),
20113            _ => local_var_req_builder.query(&[(
20114                "created",
20115                &local_var_str
20116                    .into_iter()
20117                    .map(|p| p.to_string())
20118                    .collect::<Vec<String>>()
20119                    .join(",")
20120                    .to_string(),
20121            )]),
20122        };
20123    }
20124    if let Some(ref local_var_str) = device {
20125        local_var_req_builder = match "multi" {
20126            "multi" => local_var_req_builder.query(
20127                &local_var_str
20128                    .into_iter()
20129                    .map(|p| ("device".to_owned(), p.to_string()))
20130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20131            ),
20132            _ => local_var_req_builder.query(&[(
20133                "device",
20134                &local_var_str
20135                    .into_iter()
20136                    .map(|p| p.to_string())
20137                    .collect::<Vec<String>>()
20138                    .join(",")
20139                    .to_string(),
20140            )]),
20141        };
20142    }
20143    if let Some(ref local_var_str) = device__isnull {
20144        local_var_req_builder =
20145            local_var_req_builder.query(&[("device__isnull", &local_var_str.to_string())]);
20146    }
20147    if let Some(ref local_var_str) = device__n {
20148        local_var_req_builder = match "multi" {
20149            "multi" => local_var_req_builder.query(
20150                &local_var_str
20151                    .into_iter()
20152                    .map(|p| ("device__n".to_owned(), p.to_string()))
20153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20154            ),
20155            _ => local_var_req_builder.query(&[(
20156                "device__n",
20157                &local_var_str
20158                    .into_iter()
20159                    .map(|p| p.to_string())
20160                    .collect::<Vec<String>>()
20161                    .join(",")
20162                    .to_string(),
20163            )]),
20164        };
20165    }
20166    if let Some(ref local_var_str) = format {
20167        local_var_req_builder =
20168            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
20169    }
20170    if let Some(ref local_var_str) = id {
20171        local_var_req_builder = match "multi" {
20172            "multi" => local_var_req_builder.query(
20173                &local_var_str
20174                    .into_iter()
20175                    .map(|p| ("id".to_owned(), p.to_string()))
20176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20177            ),
20178            _ => local_var_req_builder.query(&[(
20179                "id",
20180                &local_var_str
20181                    .into_iter()
20182                    .map(|p| p.to_string())
20183                    .collect::<Vec<String>>()
20184                    .join(",")
20185                    .to_string(),
20186            )]),
20187        };
20188    }
20189    if let Some(ref local_var_str) = id__n {
20190        local_var_req_builder = match "multi" {
20191            "multi" => local_var_req_builder.query(
20192                &local_var_str
20193                    .into_iter()
20194                    .map(|p| ("id__n".to_owned(), p.to_string()))
20195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20196            ),
20197            _ => local_var_req_builder.query(&[(
20198                "id__n",
20199                &local_var_str
20200                    .into_iter()
20201                    .map(|p| p.to_string())
20202                    .collect::<Vec<String>>()
20203                    .join(",")
20204                    .to_string(),
20205            )]),
20206        };
20207    }
20208    if let Some(ref local_var_str) = last_updated {
20209        local_var_req_builder = match "multi" {
20210            "multi" => local_var_req_builder.query(
20211                &local_var_str
20212                    .into_iter()
20213                    .map(|p| ("last_updated".to_owned(), p.to_string()))
20214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20215            ),
20216            _ => local_var_req_builder.query(&[(
20217                "last_updated",
20218                &local_var_str
20219                    .into_iter()
20220                    .map(|p| p.to_string())
20221                    .collect::<Vec<String>>()
20222                    .join(",")
20223                    .to_string(),
20224            )]),
20225        };
20226    }
20227    if let Some(ref local_var_str) = limit {
20228        local_var_req_builder =
20229            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
20230    }
20231    if let Some(ref local_var_str) = name {
20232        local_var_req_builder = match "multi" {
20233            "multi" => local_var_req_builder.query(
20234                &local_var_str
20235                    .into_iter()
20236                    .map(|p| ("name".to_owned(), p.to_string()))
20237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20238            ),
20239            _ => local_var_req_builder.query(&[(
20240                "name",
20241                &local_var_str
20242                    .into_iter()
20243                    .map(|p| p.to_string())
20244                    .collect::<Vec<String>>()
20245                    .join(",")
20246                    .to_string(),
20247            )]),
20248        };
20249    }
20250    if let Some(ref local_var_str) = name__ic {
20251        local_var_req_builder = match "multi" {
20252            "multi" => local_var_req_builder.query(
20253                &local_var_str
20254                    .into_iter()
20255                    .map(|p| ("name__ic".to_owned(), p.to_string()))
20256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20257            ),
20258            _ => local_var_req_builder.query(&[(
20259                "name__ic",
20260                &local_var_str
20261                    .into_iter()
20262                    .map(|p| p.to_string())
20263                    .collect::<Vec<String>>()
20264                    .join(",")
20265                    .to_string(),
20266            )]),
20267        };
20268    }
20269    if let Some(ref local_var_str) = name__ie {
20270        local_var_req_builder = match "multi" {
20271            "multi" => local_var_req_builder.query(
20272                &local_var_str
20273                    .into_iter()
20274                    .map(|p| ("name__ie".to_owned(), p.to_string()))
20275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20276            ),
20277            _ => local_var_req_builder.query(&[(
20278                "name__ie",
20279                &local_var_str
20280                    .into_iter()
20281                    .map(|p| p.to_string())
20282                    .collect::<Vec<String>>()
20283                    .join(",")
20284                    .to_string(),
20285            )]),
20286        };
20287    }
20288    if let Some(ref local_var_str) = name__iew {
20289        local_var_req_builder = match "multi" {
20290            "multi" => local_var_req_builder.query(
20291                &local_var_str
20292                    .into_iter()
20293                    .map(|p| ("name__iew".to_owned(), p.to_string()))
20294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20295            ),
20296            _ => local_var_req_builder.query(&[(
20297                "name__iew",
20298                &local_var_str
20299                    .into_iter()
20300                    .map(|p| p.to_string())
20301                    .collect::<Vec<String>>()
20302                    .join(",")
20303                    .to_string(),
20304            )]),
20305        };
20306    }
20307    if let Some(ref local_var_str) = name__ire {
20308        local_var_req_builder = match "multi" {
20309            "multi" => local_var_req_builder.query(
20310                &local_var_str
20311                    .into_iter()
20312                    .map(|p| ("name__ire".to_owned(), p.to_string()))
20313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20314            ),
20315            _ => local_var_req_builder.query(&[(
20316                "name__ire",
20317                &local_var_str
20318                    .into_iter()
20319                    .map(|p| p.to_string())
20320                    .collect::<Vec<String>>()
20321                    .join(",")
20322                    .to_string(),
20323            )]),
20324        };
20325    }
20326    if let Some(ref local_var_str) = name__isw {
20327        local_var_req_builder = match "multi" {
20328            "multi" => local_var_req_builder.query(
20329                &local_var_str
20330                    .into_iter()
20331                    .map(|p| ("name__isw".to_owned(), p.to_string()))
20332                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20333            ),
20334            _ => local_var_req_builder.query(&[(
20335                "name__isw",
20336                &local_var_str
20337                    .into_iter()
20338                    .map(|p| p.to_string())
20339                    .collect::<Vec<String>>()
20340                    .join(",")
20341                    .to_string(),
20342            )]),
20343        };
20344    }
20345    if let Some(ref local_var_str) = name__n {
20346        local_var_req_builder = match "multi" {
20347            "multi" => local_var_req_builder.query(
20348                &local_var_str
20349                    .into_iter()
20350                    .map(|p| ("name__n".to_owned(), p.to_string()))
20351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20352            ),
20353            _ => local_var_req_builder.query(&[(
20354                "name__n",
20355                &local_var_str
20356                    .into_iter()
20357                    .map(|p| p.to_string())
20358                    .collect::<Vec<String>>()
20359                    .join(",")
20360                    .to_string(),
20361            )]),
20362        };
20363    }
20364    if let Some(ref local_var_str) = name__nic {
20365        local_var_req_builder = match "multi" {
20366            "multi" => local_var_req_builder.query(
20367                &local_var_str
20368                    .into_iter()
20369                    .map(|p| ("name__nic".to_owned(), p.to_string()))
20370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20371            ),
20372            _ => local_var_req_builder.query(&[(
20373                "name__nic",
20374                &local_var_str
20375                    .into_iter()
20376                    .map(|p| p.to_string())
20377                    .collect::<Vec<String>>()
20378                    .join(",")
20379                    .to_string(),
20380            )]),
20381        };
20382    }
20383    if let Some(ref local_var_str) = name__nie {
20384        local_var_req_builder = match "multi" {
20385            "multi" => local_var_req_builder.query(
20386                &local_var_str
20387                    .into_iter()
20388                    .map(|p| ("name__nie".to_owned(), p.to_string()))
20389                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20390            ),
20391            _ => local_var_req_builder.query(&[(
20392                "name__nie",
20393                &local_var_str
20394                    .into_iter()
20395                    .map(|p| p.to_string())
20396                    .collect::<Vec<String>>()
20397                    .join(",")
20398                    .to_string(),
20399            )]),
20400        };
20401    }
20402    if let Some(ref local_var_str) = name__niew {
20403        local_var_req_builder = match "multi" {
20404            "multi" => local_var_req_builder.query(
20405                &local_var_str
20406                    .into_iter()
20407                    .map(|p| ("name__niew".to_owned(), p.to_string()))
20408                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20409            ),
20410            _ => local_var_req_builder.query(&[(
20411                "name__niew",
20412                &local_var_str
20413                    .into_iter()
20414                    .map(|p| p.to_string())
20415                    .collect::<Vec<String>>()
20416                    .join(",")
20417                    .to_string(),
20418            )]),
20419        };
20420    }
20421    if let Some(ref local_var_str) = name__nire {
20422        local_var_req_builder = match "multi" {
20423            "multi" => local_var_req_builder.query(
20424                &local_var_str
20425                    .into_iter()
20426                    .map(|p| ("name__nire".to_owned(), p.to_string()))
20427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20428            ),
20429            _ => local_var_req_builder.query(&[(
20430                "name__nire",
20431                &local_var_str
20432                    .into_iter()
20433                    .map(|p| p.to_string())
20434                    .collect::<Vec<String>>()
20435                    .join(",")
20436                    .to_string(),
20437            )]),
20438        };
20439    }
20440    if let Some(ref local_var_str) = name__nisw {
20441        local_var_req_builder = match "multi" {
20442            "multi" => local_var_req_builder.query(
20443                &local_var_str
20444                    .into_iter()
20445                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
20446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20447            ),
20448            _ => local_var_req_builder.query(&[(
20449                "name__nisw",
20450                &local_var_str
20451                    .into_iter()
20452                    .map(|p| p.to_string())
20453                    .collect::<Vec<String>>()
20454                    .join(",")
20455                    .to_string(),
20456            )]),
20457        };
20458    }
20459    if let Some(ref local_var_str) = name__nre {
20460        local_var_req_builder = match "multi" {
20461            "multi" => local_var_req_builder.query(
20462                &local_var_str
20463                    .into_iter()
20464                    .map(|p| ("name__nre".to_owned(), p.to_string()))
20465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20466            ),
20467            _ => local_var_req_builder.query(&[(
20468                "name__nre",
20469                &local_var_str
20470                    .into_iter()
20471                    .map(|p| p.to_string())
20472                    .collect::<Vec<String>>()
20473                    .join(",")
20474                    .to_string(),
20475            )]),
20476        };
20477    }
20478    if let Some(ref local_var_str) = name__re {
20479        local_var_req_builder = match "multi" {
20480            "multi" => local_var_req_builder.query(
20481                &local_var_str
20482                    .into_iter()
20483                    .map(|p| ("name__re".to_owned(), p.to_string()))
20484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20485            ),
20486            _ => local_var_req_builder.query(&[(
20487                "name__re",
20488                &local_var_str
20489                    .into_iter()
20490                    .map(|p| p.to_string())
20491                    .collect::<Vec<String>>()
20492                    .join(",")
20493                    .to_string(),
20494            )]),
20495        };
20496    }
20497    if let Some(ref local_var_str) = offset {
20498        local_var_req_builder =
20499            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
20500    }
20501    if let Some(ref local_var_str) = q {
20502        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
20503    }
20504    if let Some(ref local_var_str) = rd {
20505        local_var_req_builder = match "multi" {
20506            "multi" => local_var_req_builder.query(
20507                &local_var_str
20508                    .into_iter()
20509                    .map(|p| ("rd".to_owned(), p.to_string()))
20510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20511            ),
20512            _ => local_var_req_builder.query(&[(
20513                "rd",
20514                &local_var_str
20515                    .into_iter()
20516                    .map(|p| p.to_string())
20517                    .collect::<Vec<String>>()
20518                    .join(",")
20519                    .to_string(),
20520            )]),
20521        };
20522    }
20523    if let Some(ref local_var_str) = rd__ic {
20524        local_var_req_builder = match "multi" {
20525            "multi" => local_var_req_builder.query(
20526                &local_var_str
20527                    .into_iter()
20528                    .map(|p| ("rd__ic".to_owned(), p.to_string()))
20529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20530            ),
20531            _ => local_var_req_builder.query(&[(
20532                "rd__ic",
20533                &local_var_str
20534                    .into_iter()
20535                    .map(|p| p.to_string())
20536                    .collect::<Vec<String>>()
20537                    .join(",")
20538                    .to_string(),
20539            )]),
20540        };
20541    }
20542    if let Some(ref local_var_str) = rd__ie {
20543        local_var_req_builder = match "multi" {
20544            "multi" => local_var_req_builder.query(
20545                &local_var_str
20546                    .into_iter()
20547                    .map(|p| ("rd__ie".to_owned(), p.to_string()))
20548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20549            ),
20550            _ => local_var_req_builder.query(&[(
20551                "rd__ie",
20552                &local_var_str
20553                    .into_iter()
20554                    .map(|p| p.to_string())
20555                    .collect::<Vec<String>>()
20556                    .join(",")
20557                    .to_string(),
20558            )]),
20559        };
20560    }
20561    if let Some(ref local_var_str) = rd__iew {
20562        local_var_req_builder = match "multi" {
20563            "multi" => local_var_req_builder.query(
20564                &local_var_str
20565                    .into_iter()
20566                    .map(|p| ("rd__iew".to_owned(), p.to_string()))
20567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20568            ),
20569            _ => local_var_req_builder.query(&[(
20570                "rd__iew",
20571                &local_var_str
20572                    .into_iter()
20573                    .map(|p| p.to_string())
20574                    .collect::<Vec<String>>()
20575                    .join(",")
20576                    .to_string(),
20577            )]),
20578        };
20579    }
20580    if let Some(ref local_var_str) = rd__ire {
20581        local_var_req_builder = match "multi" {
20582            "multi" => local_var_req_builder.query(
20583                &local_var_str
20584                    .into_iter()
20585                    .map(|p| ("rd__ire".to_owned(), p.to_string()))
20586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20587            ),
20588            _ => local_var_req_builder.query(&[(
20589                "rd__ire",
20590                &local_var_str
20591                    .into_iter()
20592                    .map(|p| p.to_string())
20593                    .collect::<Vec<String>>()
20594                    .join(",")
20595                    .to_string(),
20596            )]),
20597        };
20598    }
20599    if let Some(ref local_var_str) = rd__isnull {
20600        local_var_req_builder =
20601            local_var_req_builder.query(&[("rd__isnull", &local_var_str.to_string())]);
20602    }
20603    if let Some(ref local_var_str) = rd__isw {
20604        local_var_req_builder = match "multi" {
20605            "multi" => local_var_req_builder.query(
20606                &local_var_str
20607                    .into_iter()
20608                    .map(|p| ("rd__isw".to_owned(), p.to_string()))
20609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20610            ),
20611            _ => local_var_req_builder.query(&[(
20612                "rd__isw",
20613                &local_var_str
20614                    .into_iter()
20615                    .map(|p| p.to_string())
20616                    .collect::<Vec<String>>()
20617                    .join(",")
20618                    .to_string(),
20619            )]),
20620        };
20621    }
20622    if let Some(ref local_var_str) = rd__n {
20623        local_var_req_builder = match "multi" {
20624            "multi" => local_var_req_builder.query(
20625                &local_var_str
20626                    .into_iter()
20627                    .map(|p| ("rd__n".to_owned(), p.to_string()))
20628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20629            ),
20630            _ => local_var_req_builder.query(&[(
20631                "rd__n",
20632                &local_var_str
20633                    .into_iter()
20634                    .map(|p| p.to_string())
20635                    .collect::<Vec<String>>()
20636                    .join(",")
20637                    .to_string(),
20638            )]),
20639        };
20640    }
20641    if let Some(ref local_var_str) = rd__nic {
20642        local_var_req_builder = match "multi" {
20643            "multi" => local_var_req_builder.query(
20644                &local_var_str
20645                    .into_iter()
20646                    .map(|p| ("rd__nic".to_owned(), p.to_string()))
20647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20648            ),
20649            _ => local_var_req_builder.query(&[(
20650                "rd__nic",
20651                &local_var_str
20652                    .into_iter()
20653                    .map(|p| p.to_string())
20654                    .collect::<Vec<String>>()
20655                    .join(",")
20656                    .to_string(),
20657            )]),
20658        };
20659    }
20660    if let Some(ref local_var_str) = rd__nie {
20661        local_var_req_builder = match "multi" {
20662            "multi" => local_var_req_builder.query(
20663                &local_var_str
20664                    .into_iter()
20665                    .map(|p| ("rd__nie".to_owned(), p.to_string()))
20666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20667            ),
20668            _ => local_var_req_builder.query(&[(
20669                "rd__nie",
20670                &local_var_str
20671                    .into_iter()
20672                    .map(|p| p.to_string())
20673                    .collect::<Vec<String>>()
20674                    .join(",")
20675                    .to_string(),
20676            )]),
20677        };
20678    }
20679    if let Some(ref local_var_str) = rd__niew {
20680        local_var_req_builder = match "multi" {
20681            "multi" => local_var_req_builder.query(
20682                &local_var_str
20683                    .into_iter()
20684                    .map(|p| ("rd__niew".to_owned(), p.to_string()))
20685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20686            ),
20687            _ => local_var_req_builder.query(&[(
20688                "rd__niew",
20689                &local_var_str
20690                    .into_iter()
20691                    .map(|p| p.to_string())
20692                    .collect::<Vec<String>>()
20693                    .join(",")
20694                    .to_string(),
20695            )]),
20696        };
20697    }
20698    if let Some(ref local_var_str) = rd__nire {
20699        local_var_req_builder = match "multi" {
20700            "multi" => local_var_req_builder.query(
20701                &local_var_str
20702                    .into_iter()
20703                    .map(|p| ("rd__nire".to_owned(), p.to_string()))
20704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20705            ),
20706            _ => local_var_req_builder.query(&[(
20707                "rd__nire",
20708                &local_var_str
20709                    .into_iter()
20710                    .map(|p| p.to_string())
20711                    .collect::<Vec<String>>()
20712                    .join(",")
20713                    .to_string(),
20714            )]),
20715        };
20716    }
20717    if let Some(ref local_var_str) = rd__nisw {
20718        local_var_req_builder = match "multi" {
20719            "multi" => local_var_req_builder.query(
20720                &local_var_str
20721                    .into_iter()
20722                    .map(|p| ("rd__nisw".to_owned(), p.to_string()))
20723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20724            ),
20725            _ => local_var_req_builder.query(&[(
20726                "rd__nisw",
20727                &local_var_str
20728                    .into_iter()
20729                    .map(|p| p.to_string())
20730                    .collect::<Vec<String>>()
20731                    .join(",")
20732                    .to_string(),
20733            )]),
20734        };
20735    }
20736    if let Some(ref local_var_str) = rd__nre {
20737        local_var_req_builder = match "multi" {
20738            "multi" => local_var_req_builder.query(
20739                &local_var_str
20740                    .into_iter()
20741                    .map(|p| ("rd__nre".to_owned(), p.to_string()))
20742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20743            ),
20744            _ => local_var_req_builder.query(&[(
20745                "rd__nre",
20746                &local_var_str
20747                    .into_iter()
20748                    .map(|p| p.to_string())
20749                    .collect::<Vec<String>>()
20750                    .join(",")
20751                    .to_string(),
20752            )]),
20753        };
20754    }
20755    if let Some(ref local_var_str) = rd__re {
20756        local_var_req_builder = match "multi" {
20757            "multi" => local_var_req_builder.query(
20758                &local_var_str
20759                    .into_iter()
20760                    .map(|p| ("rd__re".to_owned(), p.to_string()))
20761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20762            ),
20763            _ => local_var_req_builder.query(&[(
20764                "rd__re",
20765                &local_var_str
20766                    .into_iter()
20767                    .map(|p| p.to_string())
20768                    .collect::<Vec<String>>()
20769                    .join(",")
20770                    .to_string(),
20771            )]),
20772        };
20773    }
20774    if let Some(ref local_var_str) = sort {
20775        local_var_req_builder =
20776            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
20777    }
20778    if let Some(ref local_var_str) = virtual_device_context {
20779        local_var_req_builder = match "multi" {
20780            "multi" => local_var_req_builder.query(
20781                &local_var_str
20782                    .into_iter()
20783                    .map(|p| ("virtual_device_context".to_owned(), p.to_string()))
20784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20785            ),
20786            _ => local_var_req_builder.query(&[(
20787                "virtual_device_context",
20788                &local_var_str
20789                    .into_iter()
20790                    .map(|p| p.to_string())
20791                    .collect::<Vec<String>>()
20792                    .join(",")
20793                    .to_string(),
20794            )]),
20795        };
20796    }
20797    if let Some(ref local_var_str) = virtual_device_context__isnull {
20798        local_var_req_builder = local_var_req_builder
20799            .query(&[("virtual_device_context__isnull", &local_var_str.to_string())]);
20800    }
20801    if let Some(ref local_var_str) = virtual_device_context__n {
20802        local_var_req_builder = match "multi" {
20803            "multi" => local_var_req_builder.query(
20804                &local_var_str
20805                    .into_iter()
20806                    .map(|p| ("virtual_device_context__n".to_owned(), p.to_string()))
20807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20808            ),
20809            _ => local_var_req_builder.query(&[(
20810                "virtual_device_context__n",
20811                &local_var_str
20812                    .into_iter()
20813                    .map(|p| p.to_string())
20814                    .collect::<Vec<String>>()
20815                    .join(",")
20816                    .to_string(),
20817            )]),
20818        };
20819    }
20820    if let Some(ref local_var_str) = virtual_machine {
20821        local_var_req_builder = match "multi" {
20822            "multi" => local_var_req_builder.query(
20823                &local_var_str
20824                    .into_iter()
20825                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
20826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20827            ),
20828            _ => local_var_req_builder.query(&[(
20829                "virtual_machine",
20830                &local_var_str
20831                    .into_iter()
20832                    .map(|p| p.to_string())
20833                    .collect::<Vec<String>>()
20834                    .join(",")
20835                    .to_string(),
20836            )]),
20837        };
20838    }
20839    if let Some(ref local_var_str) = virtual_machine__isnull {
20840        local_var_req_builder =
20841            local_var_req_builder.query(&[("virtual_machine__isnull", &local_var_str.to_string())]);
20842    }
20843    if let Some(ref local_var_str) = virtual_machine__n {
20844        local_var_req_builder = match "multi" {
20845            "multi" => local_var_req_builder.query(
20846                &local_var_str
20847                    .into_iter()
20848                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
20849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20850            ),
20851            _ => local_var_req_builder.query(&[(
20852                "virtual_machine__n",
20853                &local_var_str
20854                    .into_iter()
20855                    .map(|p| p.to_string())
20856                    .collect::<Vec<String>>()
20857                    .join(",")
20858                    .to_string(),
20859            )]),
20860        };
20861    }
20862    if let Some(ref local_var_str) = vrf {
20863        local_var_req_builder = match "multi" {
20864            "multi" => local_var_req_builder.query(
20865                &local_var_str
20866                    .into_iter()
20867                    .map(|p| ("vrf".to_owned(), p.to_string()))
20868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20869            ),
20870            _ => local_var_req_builder.query(&[(
20871                "vrf",
20872                &local_var_str
20873                    .into_iter()
20874                    .map(|p| p.to_string())
20875                    .collect::<Vec<String>>()
20876                    .join(",")
20877                    .to_string(),
20878            )]),
20879        };
20880    }
20881    if let Some(ref local_var_str) = vrf__n {
20882        local_var_req_builder = match "multi" {
20883            "multi" => local_var_req_builder.query(
20884                &local_var_str
20885                    .into_iter()
20886                    .map(|p| ("vrf__n".to_owned(), p.to_string()))
20887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20888            ),
20889            _ => local_var_req_builder.query(&[(
20890                "vrf__n",
20891                &local_var_str
20892                    .into_iter()
20893                    .map(|p| p.to_string())
20894                    .collect::<Vec<String>>()
20895                    .join(",")
20896                    .to_string(),
20897            )]),
20898        };
20899    }
20900    if let Some(ref local_var_str) = depth {
20901        local_var_req_builder =
20902            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
20903    }
20904    if let Some(ref local_var_str) = exclude_m2m {
20905        local_var_req_builder =
20906            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
20907    }
20908    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20909        local_var_req_builder =
20910            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20911    }
20912    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20913        let local_var_key = local_var_apikey.key.clone();
20914        let local_var_value = match local_var_apikey.prefix {
20915            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20916            None => local_var_key,
20917        };
20918        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20919    };
20920
20921    let local_var_req = local_var_req_builder.build()?;
20922    let local_var_resp = local_var_client.execute(local_var_req).await?;
20923
20924    let local_var_status = local_var_resp.status();
20925    let local_var_content = local_var_resp.text().await?;
20926
20927    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20928        serde_json::from_str(&local_var_content).map_err(Error::from)
20929    } else {
20930        let local_var_entity: Option<IpamVrfDeviceAssignmentsListError> =
20931            serde_json::from_str(&local_var_content).ok();
20932        let local_var_error = ResponseContent {
20933            status: local_var_status,
20934            content: local_var_content,
20935            entity: local_var_entity,
20936        };
20937        Err(Error::ResponseError(local_var_error))
20938    }
20939}
20940
20941/// Partial update a VRF-device assignment object.
20942pub async fn ipam_vrf_device_assignments_partial_update(
20943    configuration: &configuration::Configuration,
20944    id: &str,
20945    format: Option<&str>,
20946    patched_vrf_device_assignment_request: Option<crate::models::PatchedVrfDeviceAssignmentRequest>,
20947) -> Result<crate::models::VrfDeviceAssignment, Error<IpamVrfDeviceAssignmentsPartialUpdateError>> {
20948    let local_var_configuration = configuration;
20949
20950    let local_var_client = &local_var_configuration.client;
20951
20952    let local_var_uri_str = format!(
20953        "{}/ipam/vrf-device-assignments/{id}/",
20954        local_var_configuration.base_path,
20955        id = crate::apis::urlencode(id)
20956    );
20957    let mut local_var_req_builder =
20958        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
20959
20960    if let Some(ref local_var_str) = format {
20961        local_var_req_builder =
20962            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
20963    }
20964    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20965        local_var_req_builder =
20966            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20967    }
20968    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20969        let local_var_key = local_var_apikey.key.clone();
20970        let local_var_value = match local_var_apikey.prefix {
20971            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20972            None => local_var_key,
20973        };
20974        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20975    };
20976    local_var_req_builder = local_var_req_builder.json(&patched_vrf_device_assignment_request);
20977
20978    let local_var_req = local_var_req_builder.build()?;
20979    let local_var_resp = local_var_client.execute(local_var_req).await?;
20980
20981    let local_var_status = local_var_resp.status();
20982    let local_var_content = local_var_resp.text().await?;
20983
20984    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20985        serde_json::from_str(&local_var_content).map_err(Error::from)
20986    } else {
20987        let local_var_entity: Option<IpamVrfDeviceAssignmentsPartialUpdateError> =
20988            serde_json::from_str(&local_var_content).ok();
20989        let local_var_error = ResponseContent {
20990            status: local_var_status,
20991            content: local_var_content,
20992            entity: local_var_entity,
20993        };
20994        Err(Error::ResponseError(local_var_error))
20995    }
20996}
20997
20998/// Retrieve a VRF-device assignment object.
20999pub async fn ipam_vrf_device_assignments_retrieve(
21000    configuration: &configuration::Configuration,
21001    id: &str,
21002    format: Option<&str>,
21003    depth: Option<i32>,
21004    exclude_m2m: Option<bool>,
21005) -> Result<crate::models::VrfDeviceAssignment, Error<IpamVrfDeviceAssignmentsRetrieveError>> {
21006    let local_var_configuration = configuration;
21007
21008    let local_var_client = &local_var_configuration.client;
21009
21010    let local_var_uri_str = format!(
21011        "{}/ipam/vrf-device-assignments/{id}/",
21012        local_var_configuration.base_path,
21013        id = crate::apis::urlencode(id)
21014    );
21015    let mut local_var_req_builder =
21016        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21017
21018    if let Some(ref local_var_str) = format {
21019        local_var_req_builder =
21020            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21021    }
21022    if let Some(ref local_var_str) = depth {
21023        local_var_req_builder =
21024            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
21025    }
21026    if let Some(ref local_var_str) = exclude_m2m {
21027        local_var_req_builder =
21028            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
21029    }
21030    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21031        local_var_req_builder =
21032            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21033    }
21034    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21035        let local_var_key = local_var_apikey.key.clone();
21036        let local_var_value = match local_var_apikey.prefix {
21037            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21038            None => local_var_key,
21039        };
21040        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21041    };
21042
21043    let local_var_req = local_var_req_builder.build()?;
21044    let local_var_resp = local_var_client.execute(local_var_req).await?;
21045
21046    let local_var_status = local_var_resp.status();
21047    let local_var_content = local_var_resp.text().await?;
21048
21049    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21050        serde_json::from_str(&local_var_content).map_err(Error::from)
21051    } else {
21052        let local_var_entity: Option<IpamVrfDeviceAssignmentsRetrieveError> =
21053            serde_json::from_str(&local_var_content).ok();
21054        let local_var_error = ResponseContent {
21055            status: local_var_status,
21056            content: local_var_content,
21057            entity: local_var_entity,
21058        };
21059        Err(Error::ResponseError(local_var_error))
21060    }
21061}
21062
21063/// Update a VRF-device assignment object.
21064pub async fn ipam_vrf_device_assignments_update(
21065    configuration: &configuration::Configuration,
21066    id: &str,
21067    vrf_device_assignment_request: crate::models::VrfDeviceAssignmentRequest,
21068    format: Option<&str>,
21069) -> Result<crate::models::VrfDeviceAssignment, Error<IpamVrfDeviceAssignmentsUpdateError>> {
21070    let local_var_configuration = configuration;
21071
21072    let local_var_client = &local_var_configuration.client;
21073
21074    let local_var_uri_str = format!(
21075        "{}/ipam/vrf-device-assignments/{id}/",
21076        local_var_configuration.base_path,
21077        id = crate::apis::urlencode(id)
21078    );
21079    let mut local_var_req_builder =
21080        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21081
21082    if let Some(ref local_var_str) = format {
21083        local_var_req_builder =
21084            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21085    }
21086    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21087        local_var_req_builder =
21088            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21089    }
21090    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21091        let local_var_key = local_var_apikey.key.clone();
21092        let local_var_value = match local_var_apikey.prefix {
21093            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21094            None => local_var_key,
21095        };
21096        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21097    };
21098    local_var_req_builder = local_var_req_builder.json(&vrf_device_assignment_request);
21099
21100    let local_var_req = local_var_req_builder.build()?;
21101    let local_var_resp = local_var_client.execute(local_var_req).await?;
21102
21103    let local_var_status = local_var_resp.status();
21104    let local_var_content = local_var_resp.text().await?;
21105
21106    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21107        serde_json::from_str(&local_var_content).map_err(Error::from)
21108    } else {
21109        let local_var_entity: Option<IpamVrfDeviceAssignmentsUpdateError> =
21110            serde_json::from_str(&local_var_content).ok();
21111        let local_var_error = ResponseContent {
21112            status: local_var_status,
21113            content: local_var_content,
21114            entity: local_var_entity,
21115        };
21116        Err(Error::ResponseError(local_var_error))
21117    }
21118}
21119
21120/// Destroy a list of VRF-prefix assignment objects.
21121pub async fn ipam_vrf_prefix_assignments_bulk_destroy(
21122    configuration: &configuration::Configuration,
21123    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
21124    format: Option<&str>,
21125) -> Result<(), Error<IpamVrfPrefixAssignmentsBulkDestroyError>> {
21126    let local_var_configuration = configuration;
21127
21128    let local_var_client = &local_var_configuration.client;
21129
21130    let local_var_uri_str = format!(
21131        "{}/ipam/vrf-prefix-assignments/",
21132        local_var_configuration.base_path
21133    );
21134    let mut local_var_req_builder =
21135        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21136
21137    if let Some(ref local_var_str) = format {
21138        local_var_req_builder =
21139            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21140    }
21141    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21142        local_var_req_builder =
21143            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21144    }
21145    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21146        let local_var_key = local_var_apikey.key.clone();
21147        let local_var_value = match local_var_apikey.prefix {
21148            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21149            None => local_var_key,
21150        };
21151        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21152    };
21153    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
21154
21155    let local_var_req = local_var_req_builder.build()?;
21156    let local_var_resp = local_var_client.execute(local_var_req).await?;
21157
21158    let local_var_status = local_var_resp.status();
21159    let local_var_content = local_var_resp.text().await?;
21160
21161    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21162        Ok(())
21163    } else {
21164        let local_var_entity: Option<IpamVrfPrefixAssignmentsBulkDestroyError> =
21165            serde_json::from_str(&local_var_content).ok();
21166        let local_var_error = ResponseContent {
21167            status: local_var_status,
21168            content: local_var_content,
21169            entity: local_var_entity,
21170        };
21171        Err(Error::ResponseError(local_var_error))
21172    }
21173}
21174
21175/// Partial update a list of VRF-prefix assignment objects.
21176pub async fn ipam_vrf_prefix_assignments_bulk_partial_update(
21177    configuration: &configuration::Configuration,
21178    patched_bulk_writable_vrf_prefix_assignment_request: Vec<
21179        crate::models::PatchedBulkWritableVrfPrefixAssignmentRequest,
21180    >,
21181    format: Option<&str>,
21182) -> Result<
21183    Vec<crate::models::VrfPrefixAssignment>,
21184    Error<IpamVrfPrefixAssignmentsBulkPartialUpdateError>,
21185> {
21186    let local_var_configuration = configuration;
21187
21188    let local_var_client = &local_var_configuration.client;
21189
21190    let local_var_uri_str = format!(
21191        "{}/ipam/vrf-prefix-assignments/",
21192        local_var_configuration.base_path
21193    );
21194    let mut local_var_req_builder =
21195        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21196
21197    if let Some(ref local_var_str) = format {
21198        local_var_req_builder =
21199            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21200    }
21201    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21202        local_var_req_builder =
21203            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21204    }
21205    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21206        let local_var_key = local_var_apikey.key.clone();
21207        let local_var_value = match local_var_apikey.prefix {
21208            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21209            None => local_var_key,
21210        };
21211        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21212    };
21213    local_var_req_builder =
21214        local_var_req_builder.json(&patched_bulk_writable_vrf_prefix_assignment_request);
21215
21216    let local_var_req = local_var_req_builder.build()?;
21217    let local_var_resp = local_var_client.execute(local_var_req).await?;
21218
21219    let local_var_status = local_var_resp.status();
21220    let local_var_content = local_var_resp.text().await?;
21221
21222    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21223        serde_json::from_str(&local_var_content).map_err(Error::from)
21224    } else {
21225        let local_var_entity: Option<IpamVrfPrefixAssignmentsBulkPartialUpdateError> =
21226            serde_json::from_str(&local_var_content).ok();
21227        let local_var_error = ResponseContent {
21228            status: local_var_status,
21229            content: local_var_content,
21230            entity: local_var_entity,
21231        };
21232        Err(Error::ResponseError(local_var_error))
21233    }
21234}
21235
21236/// Update a list of VRF-prefix assignment objects.
21237pub async fn ipam_vrf_prefix_assignments_bulk_update(
21238    configuration: &configuration::Configuration,
21239    bulk_writable_vrf_prefix_assignment_request: Vec<
21240        crate::models::BulkWritableVrfPrefixAssignmentRequest,
21241    >,
21242    format: Option<&str>,
21243) -> Result<Vec<crate::models::VrfPrefixAssignment>, Error<IpamVrfPrefixAssignmentsBulkUpdateError>>
21244{
21245    let local_var_configuration = configuration;
21246
21247    let local_var_client = &local_var_configuration.client;
21248
21249    let local_var_uri_str = format!(
21250        "{}/ipam/vrf-prefix-assignments/",
21251        local_var_configuration.base_path
21252    );
21253    let mut local_var_req_builder =
21254        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21255
21256    if let Some(ref local_var_str) = format {
21257        local_var_req_builder =
21258            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21259    }
21260    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21261        local_var_req_builder =
21262            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21263    }
21264    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21265        let local_var_key = local_var_apikey.key.clone();
21266        let local_var_value = match local_var_apikey.prefix {
21267            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21268            None => local_var_key,
21269        };
21270        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21271    };
21272    local_var_req_builder =
21273        local_var_req_builder.json(&bulk_writable_vrf_prefix_assignment_request);
21274
21275    let local_var_req = local_var_req_builder.build()?;
21276    let local_var_resp = local_var_client.execute(local_var_req).await?;
21277
21278    let local_var_status = local_var_resp.status();
21279    let local_var_content = local_var_resp.text().await?;
21280
21281    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21282        serde_json::from_str(&local_var_content).map_err(Error::from)
21283    } else {
21284        let local_var_entity: Option<IpamVrfPrefixAssignmentsBulkUpdateError> =
21285            serde_json::from_str(&local_var_content).ok();
21286        let local_var_error = ResponseContent {
21287            status: local_var_status,
21288            content: local_var_content,
21289            entity: local_var_entity,
21290        };
21291        Err(Error::ResponseError(local_var_error))
21292    }
21293}
21294
21295/// Create one or more VRF-prefix assignment objects.
21296pub async fn ipam_vrf_prefix_assignments_create(
21297    configuration: &configuration::Configuration,
21298    vrf_prefix_assignment_request: crate::models::VrfPrefixAssignmentRequest,
21299    format: Option<&str>,
21300) -> Result<crate::models::VrfPrefixAssignment, Error<IpamVrfPrefixAssignmentsCreateError>> {
21301    let local_var_configuration = configuration;
21302
21303    let local_var_client = &local_var_configuration.client;
21304
21305    let local_var_uri_str = format!(
21306        "{}/ipam/vrf-prefix-assignments/",
21307        local_var_configuration.base_path
21308    );
21309    let mut local_var_req_builder =
21310        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
21311
21312    if let Some(ref local_var_str) = format {
21313        local_var_req_builder =
21314            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21315    }
21316    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21317        local_var_req_builder =
21318            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21319    }
21320    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21321        let local_var_key = local_var_apikey.key.clone();
21322        let local_var_value = match local_var_apikey.prefix {
21323            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21324            None => local_var_key,
21325        };
21326        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21327    };
21328    local_var_req_builder = local_var_req_builder.json(&vrf_prefix_assignment_request);
21329
21330    let local_var_req = local_var_req_builder.build()?;
21331    let local_var_resp = local_var_client.execute(local_var_req).await?;
21332
21333    let local_var_status = local_var_resp.status();
21334    let local_var_content = local_var_resp.text().await?;
21335
21336    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21337        serde_json::from_str(&local_var_content).map_err(Error::from)
21338    } else {
21339        let local_var_entity: Option<IpamVrfPrefixAssignmentsCreateError> =
21340            serde_json::from_str(&local_var_content).ok();
21341        let local_var_error = ResponseContent {
21342            status: local_var_status,
21343            content: local_var_content,
21344            entity: local_var_entity,
21345        };
21346        Err(Error::ResponseError(local_var_error))
21347    }
21348}
21349
21350/// Destroy a VRF-prefix assignment object.
21351pub async fn ipam_vrf_prefix_assignments_destroy(
21352    configuration: &configuration::Configuration,
21353    id: &str,
21354    format: Option<&str>,
21355) -> Result<(), Error<IpamVrfPrefixAssignmentsDestroyError>> {
21356    let local_var_configuration = configuration;
21357
21358    let local_var_client = &local_var_configuration.client;
21359
21360    let local_var_uri_str = format!(
21361        "{}/ipam/vrf-prefix-assignments/{id}/",
21362        local_var_configuration.base_path,
21363        id = crate::apis::urlencode(id)
21364    );
21365    let mut local_var_req_builder =
21366        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21367
21368    if let Some(ref local_var_str) = format {
21369        local_var_req_builder =
21370            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21371    }
21372    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21373        local_var_req_builder =
21374            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21375    }
21376    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21377        let local_var_key = local_var_apikey.key.clone();
21378        let local_var_value = match local_var_apikey.prefix {
21379            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21380            None => local_var_key,
21381        };
21382        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21383    };
21384
21385    let local_var_req = local_var_req_builder.build()?;
21386    let local_var_resp = local_var_client.execute(local_var_req).await?;
21387
21388    let local_var_status = local_var_resp.status();
21389    let local_var_content = local_var_resp.text().await?;
21390
21391    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21392        Ok(())
21393    } else {
21394        let local_var_entity: Option<IpamVrfPrefixAssignmentsDestroyError> =
21395            serde_json::from_str(&local_var_content).ok();
21396        let local_var_error = ResponseContent {
21397            status: local_var_status,
21398            content: local_var_content,
21399            entity: local_var_entity,
21400        };
21401        Err(Error::ResponseError(local_var_error))
21402    }
21403}
21404
21405/// Retrieve a list of VRF-prefix assignment objects.
21406pub async fn ipam_vrf_prefix_assignments_list(
21407    configuration: &configuration::Configuration,
21408    created: Option<Vec<String>>,
21409    format: Option<&str>,
21410    id: Option<Vec<uuid::Uuid>>,
21411    id__n: Option<Vec<uuid::Uuid>>,
21412    last_updated: Option<Vec<String>>,
21413    limit: Option<i32>,
21414    offset: Option<i32>,
21415    prefix: Option<Vec<String>>,
21416    prefix__n: Option<Vec<String>>,
21417    q: Option<&str>,
21418    sort: Option<&str>,
21419    vrf: Option<Vec<String>>,
21420    vrf__n: Option<Vec<String>>,
21421    depth: Option<i32>,
21422    exclude_m2m: Option<bool>,
21423) -> Result<crate::models::PaginatedVrfPrefixAssignmentList, Error<IpamVrfPrefixAssignmentsListError>>
21424{
21425    let local_var_configuration = configuration;
21426
21427    let local_var_client = &local_var_configuration.client;
21428
21429    let local_var_uri_str = format!(
21430        "{}/ipam/vrf-prefix-assignments/",
21431        local_var_configuration.base_path
21432    );
21433    let mut local_var_req_builder =
21434        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21435
21436    if let Some(ref local_var_str) = created {
21437        local_var_req_builder = match "multi" {
21438            "multi" => local_var_req_builder.query(
21439                &local_var_str
21440                    .into_iter()
21441                    .map(|p| ("created".to_owned(), p.to_string()))
21442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21443            ),
21444            _ => local_var_req_builder.query(&[(
21445                "created",
21446                &local_var_str
21447                    .into_iter()
21448                    .map(|p| p.to_string())
21449                    .collect::<Vec<String>>()
21450                    .join(",")
21451                    .to_string(),
21452            )]),
21453        };
21454    }
21455    if let Some(ref local_var_str) = format {
21456        local_var_req_builder =
21457            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21458    }
21459    if let Some(ref local_var_str) = id {
21460        local_var_req_builder = match "multi" {
21461            "multi" => local_var_req_builder.query(
21462                &local_var_str
21463                    .into_iter()
21464                    .map(|p| ("id".to_owned(), p.to_string()))
21465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21466            ),
21467            _ => local_var_req_builder.query(&[(
21468                "id",
21469                &local_var_str
21470                    .into_iter()
21471                    .map(|p| p.to_string())
21472                    .collect::<Vec<String>>()
21473                    .join(",")
21474                    .to_string(),
21475            )]),
21476        };
21477    }
21478    if let Some(ref local_var_str) = id__n {
21479        local_var_req_builder = match "multi" {
21480            "multi" => local_var_req_builder.query(
21481                &local_var_str
21482                    .into_iter()
21483                    .map(|p| ("id__n".to_owned(), p.to_string()))
21484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21485            ),
21486            _ => local_var_req_builder.query(&[(
21487                "id__n",
21488                &local_var_str
21489                    .into_iter()
21490                    .map(|p| p.to_string())
21491                    .collect::<Vec<String>>()
21492                    .join(",")
21493                    .to_string(),
21494            )]),
21495        };
21496    }
21497    if let Some(ref local_var_str) = last_updated {
21498        local_var_req_builder = match "multi" {
21499            "multi" => local_var_req_builder.query(
21500                &local_var_str
21501                    .into_iter()
21502                    .map(|p| ("last_updated".to_owned(), p.to_string()))
21503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21504            ),
21505            _ => local_var_req_builder.query(&[(
21506                "last_updated",
21507                &local_var_str
21508                    .into_iter()
21509                    .map(|p| p.to_string())
21510                    .collect::<Vec<String>>()
21511                    .join(",")
21512                    .to_string(),
21513            )]),
21514        };
21515    }
21516    if let Some(ref local_var_str) = limit {
21517        local_var_req_builder =
21518            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
21519    }
21520    if let Some(ref local_var_str) = offset {
21521        local_var_req_builder =
21522            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
21523    }
21524    if let Some(ref local_var_str) = prefix {
21525        local_var_req_builder = match "multi" {
21526            "multi" => local_var_req_builder.query(
21527                &local_var_str
21528                    .into_iter()
21529                    .map(|p| ("prefix".to_owned(), p.to_string()))
21530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21531            ),
21532            _ => local_var_req_builder.query(&[(
21533                "prefix",
21534                &local_var_str
21535                    .into_iter()
21536                    .map(|p| p.to_string())
21537                    .collect::<Vec<String>>()
21538                    .join(",")
21539                    .to_string(),
21540            )]),
21541        };
21542    }
21543    if let Some(ref local_var_str) = prefix__n {
21544        local_var_req_builder = match "multi" {
21545            "multi" => local_var_req_builder.query(
21546                &local_var_str
21547                    .into_iter()
21548                    .map(|p| ("prefix__n".to_owned(), p.to_string()))
21549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21550            ),
21551            _ => local_var_req_builder.query(&[(
21552                "prefix__n",
21553                &local_var_str
21554                    .into_iter()
21555                    .map(|p| p.to_string())
21556                    .collect::<Vec<String>>()
21557                    .join(",")
21558                    .to_string(),
21559            )]),
21560        };
21561    }
21562    if let Some(ref local_var_str) = q {
21563        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
21564    }
21565    if let Some(ref local_var_str) = sort {
21566        local_var_req_builder =
21567            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
21568    }
21569    if let Some(ref local_var_str) = vrf {
21570        local_var_req_builder = match "multi" {
21571            "multi" => local_var_req_builder.query(
21572                &local_var_str
21573                    .into_iter()
21574                    .map(|p| ("vrf".to_owned(), p.to_string()))
21575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21576            ),
21577            _ => local_var_req_builder.query(&[(
21578                "vrf",
21579                &local_var_str
21580                    .into_iter()
21581                    .map(|p| p.to_string())
21582                    .collect::<Vec<String>>()
21583                    .join(",")
21584                    .to_string(),
21585            )]),
21586        };
21587    }
21588    if let Some(ref local_var_str) = vrf__n {
21589        local_var_req_builder = match "multi" {
21590            "multi" => local_var_req_builder.query(
21591                &local_var_str
21592                    .into_iter()
21593                    .map(|p| ("vrf__n".to_owned(), p.to_string()))
21594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21595            ),
21596            _ => local_var_req_builder.query(&[(
21597                "vrf__n",
21598                &local_var_str
21599                    .into_iter()
21600                    .map(|p| p.to_string())
21601                    .collect::<Vec<String>>()
21602                    .join(",")
21603                    .to_string(),
21604            )]),
21605        };
21606    }
21607    if let Some(ref local_var_str) = depth {
21608        local_var_req_builder =
21609            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
21610    }
21611    if let Some(ref local_var_str) = exclude_m2m {
21612        local_var_req_builder =
21613            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
21614    }
21615    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21616        local_var_req_builder =
21617            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21618    }
21619    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21620        let local_var_key = local_var_apikey.key.clone();
21621        let local_var_value = match local_var_apikey.prefix {
21622            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21623            None => local_var_key,
21624        };
21625        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21626    };
21627
21628    let local_var_req = local_var_req_builder.build()?;
21629    let local_var_resp = local_var_client.execute(local_var_req).await?;
21630
21631    let local_var_status = local_var_resp.status();
21632    let local_var_content = local_var_resp.text().await?;
21633
21634    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21635        serde_json::from_str(&local_var_content).map_err(Error::from)
21636    } else {
21637        let local_var_entity: Option<IpamVrfPrefixAssignmentsListError> =
21638            serde_json::from_str(&local_var_content).ok();
21639        let local_var_error = ResponseContent {
21640            status: local_var_status,
21641            content: local_var_content,
21642            entity: local_var_entity,
21643        };
21644        Err(Error::ResponseError(local_var_error))
21645    }
21646}
21647
21648/// Partial update a VRF-prefix assignment object.
21649pub async fn ipam_vrf_prefix_assignments_partial_update(
21650    configuration: &configuration::Configuration,
21651    id: &str,
21652    format: Option<&str>,
21653    patched_vrf_prefix_assignment_request: Option<crate::models::PatchedVrfPrefixAssignmentRequest>,
21654) -> Result<crate::models::VrfPrefixAssignment, Error<IpamVrfPrefixAssignmentsPartialUpdateError>> {
21655    let local_var_configuration = configuration;
21656
21657    let local_var_client = &local_var_configuration.client;
21658
21659    let local_var_uri_str = format!(
21660        "{}/ipam/vrf-prefix-assignments/{id}/",
21661        local_var_configuration.base_path,
21662        id = crate::apis::urlencode(id)
21663    );
21664    let mut local_var_req_builder =
21665        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21666
21667    if let Some(ref local_var_str) = format {
21668        local_var_req_builder =
21669            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21670    }
21671    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21672        local_var_req_builder =
21673            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21674    }
21675    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21676        let local_var_key = local_var_apikey.key.clone();
21677        let local_var_value = match local_var_apikey.prefix {
21678            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21679            None => local_var_key,
21680        };
21681        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21682    };
21683    local_var_req_builder = local_var_req_builder.json(&patched_vrf_prefix_assignment_request);
21684
21685    let local_var_req = local_var_req_builder.build()?;
21686    let local_var_resp = local_var_client.execute(local_var_req).await?;
21687
21688    let local_var_status = local_var_resp.status();
21689    let local_var_content = local_var_resp.text().await?;
21690
21691    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21692        serde_json::from_str(&local_var_content).map_err(Error::from)
21693    } else {
21694        let local_var_entity: Option<IpamVrfPrefixAssignmentsPartialUpdateError> =
21695            serde_json::from_str(&local_var_content).ok();
21696        let local_var_error = ResponseContent {
21697            status: local_var_status,
21698            content: local_var_content,
21699            entity: local_var_entity,
21700        };
21701        Err(Error::ResponseError(local_var_error))
21702    }
21703}
21704
21705/// Retrieve a VRF-prefix assignment object.
21706pub async fn ipam_vrf_prefix_assignments_retrieve(
21707    configuration: &configuration::Configuration,
21708    id: &str,
21709    format: Option<&str>,
21710    depth: Option<i32>,
21711    exclude_m2m: Option<bool>,
21712) -> Result<crate::models::VrfPrefixAssignment, Error<IpamVrfPrefixAssignmentsRetrieveError>> {
21713    let local_var_configuration = configuration;
21714
21715    let local_var_client = &local_var_configuration.client;
21716
21717    let local_var_uri_str = format!(
21718        "{}/ipam/vrf-prefix-assignments/{id}/",
21719        local_var_configuration.base_path,
21720        id = crate::apis::urlencode(id)
21721    );
21722    let mut local_var_req_builder =
21723        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21724
21725    if let Some(ref local_var_str) = format {
21726        local_var_req_builder =
21727            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21728    }
21729    if let Some(ref local_var_str) = depth {
21730        local_var_req_builder =
21731            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
21732    }
21733    if let Some(ref local_var_str) = exclude_m2m {
21734        local_var_req_builder =
21735            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
21736    }
21737    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21738        local_var_req_builder =
21739            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21740    }
21741    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21742        let local_var_key = local_var_apikey.key.clone();
21743        let local_var_value = match local_var_apikey.prefix {
21744            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21745            None => local_var_key,
21746        };
21747        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21748    };
21749
21750    let local_var_req = local_var_req_builder.build()?;
21751    let local_var_resp = local_var_client.execute(local_var_req).await?;
21752
21753    let local_var_status = local_var_resp.status();
21754    let local_var_content = local_var_resp.text().await?;
21755
21756    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21757        serde_json::from_str(&local_var_content).map_err(Error::from)
21758    } else {
21759        let local_var_entity: Option<IpamVrfPrefixAssignmentsRetrieveError> =
21760            serde_json::from_str(&local_var_content).ok();
21761        let local_var_error = ResponseContent {
21762            status: local_var_status,
21763            content: local_var_content,
21764            entity: local_var_entity,
21765        };
21766        Err(Error::ResponseError(local_var_error))
21767    }
21768}
21769
21770/// Update a VRF-prefix assignment object.
21771pub async fn ipam_vrf_prefix_assignments_update(
21772    configuration: &configuration::Configuration,
21773    id: &str,
21774    vrf_prefix_assignment_request: crate::models::VrfPrefixAssignmentRequest,
21775    format: Option<&str>,
21776) -> Result<crate::models::VrfPrefixAssignment, Error<IpamVrfPrefixAssignmentsUpdateError>> {
21777    let local_var_configuration = configuration;
21778
21779    let local_var_client = &local_var_configuration.client;
21780
21781    let local_var_uri_str = format!(
21782        "{}/ipam/vrf-prefix-assignments/{id}/",
21783        local_var_configuration.base_path,
21784        id = crate::apis::urlencode(id)
21785    );
21786    let mut local_var_req_builder =
21787        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21788
21789    if let Some(ref local_var_str) = format {
21790        local_var_req_builder =
21791            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21792    }
21793    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21794        local_var_req_builder =
21795            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21796    }
21797    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21798        let local_var_key = local_var_apikey.key.clone();
21799        let local_var_value = match local_var_apikey.prefix {
21800            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21801            None => local_var_key,
21802        };
21803        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21804    };
21805    local_var_req_builder = local_var_req_builder.json(&vrf_prefix_assignment_request);
21806
21807    let local_var_req = local_var_req_builder.build()?;
21808    let local_var_resp = local_var_client.execute(local_var_req).await?;
21809
21810    let local_var_status = local_var_resp.status();
21811    let local_var_content = local_var_resp.text().await?;
21812
21813    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21814        serde_json::from_str(&local_var_content).map_err(Error::from)
21815    } else {
21816        let local_var_entity: Option<IpamVrfPrefixAssignmentsUpdateError> =
21817            serde_json::from_str(&local_var_content).ok();
21818        let local_var_error = ResponseContent {
21819            status: local_var_status,
21820            content: local_var_content,
21821            entity: local_var_entity,
21822        };
21823        Err(Error::ResponseError(local_var_error))
21824    }
21825}
21826
21827/// Destroy a list of VRF objects.
21828pub async fn ipam_vrfs_bulk_destroy(
21829    configuration: &configuration::Configuration,
21830    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
21831    format: Option<&str>,
21832) -> Result<(), Error<IpamVrfsBulkDestroyError>> {
21833    let local_var_configuration = configuration;
21834
21835    let local_var_client = &local_var_configuration.client;
21836
21837    let local_var_uri_str = format!("{}/ipam/vrfs/", local_var_configuration.base_path);
21838    let mut local_var_req_builder =
21839        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21840
21841    if let Some(ref local_var_str) = format {
21842        local_var_req_builder =
21843            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21844    }
21845    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21846        local_var_req_builder =
21847            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21848    }
21849    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21850        let local_var_key = local_var_apikey.key.clone();
21851        let local_var_value = match local_var_apikey.prefix {
21852            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21853            None => local_var_key,
21854        };
21855        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21856    };
21857    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
21858
21859    let local_var_req = local_var_req_builder.build()?;
21860    let local_var_resp = local_var_client.execute(local_var_req).await?;
21861
21862    let local_var_status = local_var_resp.status();
21863    let local_var_content = local_var_resp.text().await?;
21864
21865    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21866        Ok(())
21867    } else {
21868        let local_var_entity: Option<IpamVrfsBulkDestroyError> =
21869            serde_json::from_str(&local_var_content).ok();
21870        let local_var_error = ResponseContent {
21871            status: local_var_status,
21872            content: local_var_content,
21873            entity: local_var_entity,
21874        };
21875        Err(Error::ResponseError(local_var_error))
21876    }
21877}
21878
21879/// Partial update a list of VRF objects.
21880pub async fn ipam_vrfs_bulk_partial_update(
21881    configuration: &configuration::Configuration,
21882    patched_bulk_writable_vrf_request: Vec<crate::models::PatchedBulkWritableVrfRequest>,
21883    format: Option<&str>,
21884) -> Result<Vec<crate::models::Vrf>, Error<IpamVrfsBulkPartialUpdateError>> {
21885    let local_var_configuration = configuration;
21886
21887    let local_var_client = &local_var_configuration.client;
21888
21889    let local_var_uri_str = format!("{}/ipam/vrfs/", local_var_configuration.base_path);
21890    let mut local_var_req_builder =
21891        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21892
21893    if let Some(ref local_var_str) = format {
21894        local_var_req_builder =
21895            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21896    }
21897    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21898        local_var_req_builder =
21899            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21900    }
21901    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21902        let local_var_key = local_var_apikey.key.clone();
21903        let local_var_value = match local_var_apikey.prefix {
21904            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21905            None => local_var_key,
21906        };
21907        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21908    };
21909    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vrf_request);
21910
21911    let local_var_req = local_var_req_builder.build()?;
21912    let local_var_resp = local_var_client.execute(local_var_req).await?;
21913
21914    let local_var_status = local_var_resp.status();
21915    let local_var_content = local_var_resp.text().await?;
21916
21917    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21918        serde_json::from_str(&local_var_content).map_err(Error::from)
21919    } else {
21920        let local_var_entity: Option<IpamVrfsBulkPartialUpdateError> =
21921            serde_json::from_str(&local_var_content).ok();
21922        let local_var_error = ResponseContent {
21923            status: local_var_status,
21924            content: local_var_content,
21925            entity: local_var_entity,
21926        };
21927        Err(Error::ResponseError(local_var_error))
21928    }
21929}
21930
21931/// Update a list of VRF objects.
21932pub async fn ipam_vrfs_bulk_update(
21933    configuration: &configuration::Configuration,
21934    bulk_writable_vrf_request: Vec<crate::models::BulkWritableVrfRequest>,
21935    format: Option<&str>,
21936) -> Result<Vec<crate::models::Vrf>, Error<IpamVrfsBulkUpdateError>> {
21937    let local_var_configuration = configuration;
21938
21939    let local_var_client = &local_var_configuration.client;
21940
21941    let local_var_uri_str = format!("{}/ipam/vrfs/", local_var_configuration.base_path);
21942    let mut local_var_req_builder =
21943        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21944
21945    if let Some(ref local_var_str) = format {
21946        local_var_req_builder =
21947            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
21948    }
21949    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21950        local_var_req_builder =
21951            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21952    }
21953    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21954        let local_var_key = local_var_apikey.key.clone();
21955        let local_var_value = match local_var_apikey.prefix {
21956            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21957            None => local_var_key,
21958        };
21959        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21960    };
21961    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vrf_request);
21962
21963    let local_var_req = local_var_req_builder.build()?;
21964    let local_var_resp = local_var_client.execute(local_var_req).await?;
21965
21966    let local_var_status = local_var_resp.status();
21967    let local_var_content = local_var_resp.text().await?;
21968
21969    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21970        serde_json::from_str(&local_var_content).map_err(Error::from)
21971    } else {
21972        let local_var_entity: Option<IpamVrfsBulkUpdateError> =
21973            serde_json::from_str(&local_var_content).ok();
21974        let local_var_error = ResponseContent {
21975            status: local_var_status,
21976            content: local_var_content,
21977            entity: local_var_entity,
21978        };
21979        Err(Error::ResponseError(local_var_error))
21980    }
21981}
21982
21983/// Create one or more VRF objects.
21984pub async fn ipam_vrfs_create(
21985    configuration: &configuration::Configuration,
21986    vrf_request: crate::models::VrfRequest,
21987    format: Option<&str>,
21988) -> Result<crate::models::Vrf, Error<IpamVrfsCreateError>> {
21989    let local_var_configuration = configuration;
21990
21991    let local_var_client = &local_var_configuration.client;
21992
21993    let local_var_uri_str = format!("{}/ipam/vrfs/", local_var_configuration.base_path);
21994    let mut local_var_req_builder =
21995        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
21996
21997    if let Some(ref local_var_str) = format {
21998        local_var_req_builder =
21999            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
22000    }
22001    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
22002        local_var_req_builder =
22003            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
22004    }
22005    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
22006        let local_var_key = local_var_apikey.key.clone();
22007        let local_var_value = match local_var_apikey.prefix {
22008            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
22009            None => local_var_key,
22010        };
22011        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
22012    };
22013    local_var_req_builder = local_var_req_builder.json(&vrf_request);
22014
22015    let local_var_req = local_var_req_builder.build()?;
22016    let local_var_resp = local_var_client.execute(local_var_req).await?;
22017
22018    let local_var_status = local_var_resp.status();
22019    let local_var_content = local_var_resp.text().await?;
22020
22021    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
22022        serde_json::from_str(&local_var_content).map_err(Error::from)
22023    } else {
22024        let local_var_entity: Option<IpamVrfsCreateError> =
22025            serde_json::from_str(&local_var_content).ok();
22026        let local_var_error = ResponseContent {
22027            status: local_var_status,
22028            content: local_var_content,
22029            entity: local_var_entity,
22030        };
22031        Err(Error::ResponseError(local_var_error))
22032    }
22033}
22034
22035/// Destroy a VRF object.
22036pub async fn ipam_vrfs_destroy(
22037    configuration: &configuration::Configuration,
22038    id: &str,
22039    format: Option<&str>,
22040) -> Result<(), Error<IpamVrfsDestroyError>> {
22041    let local_var_configuration = configuration;
22042
22043    let local_var_client = &local_var_configuration.client;
22044
22045    let local_var_uri_str = format!(
22046        "{}/ipam/vrfs/{id}/",
22047        local_var_configuration.base_path,
22048        id = crate::apis::urlencode(id)
22049    );
22050    let mut local_var_req_builder =
22051        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
22052
22053    if let Some(ref local_var_str) = format {
22054        local_var_req_builder =
22055            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
22056    }
22057    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
22058        local_var_req_builder =
22059            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
22060    }
22061    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
22062        let local_var_key = local_var_apikey.key.clone();
22063        let local_var_value = match local_var_apikey.prefix {
22064            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
22065            None => local_var_key,
22066        };
22067        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
22068    };
22069
22070    let local_var_req = local_var_req_builder.build()?;
22071    let local_var_resp = local_var_client.execute(local_var_req).await?;
22072
22073    let local_var_status = local_var_resp.status();
22074    let local_var_content = local_var_resp.text().await?;
22075
22076    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
22077        Ok(())
22078    } else {
22079        let local_var_entity: Option<IpamVrfsDestroyError> =
22080            serde_json::from_str(&local_var_content).ok();
22081        let local_var_error = ResponseContent {
22082            status: local_var_status,
22083            content: local_var_content,
22084            entity: local_var_entity,
22085        };
22086        Err(Error::ResponseError(local_var_error))
22087    }
22088}
22089
22090/// Retrieve a list of VRF objects.
22091pub async fn ipam_vrfs_list(
22092    configuration: &configuration::Configuration,
22093    contacts: Option<Vec<String>>,
22094    contacts__isnull: Option<bool>,
22095    contacts__n: Option<Vec<String>>,
22096    created: Option<Vec<String>>,
22097    created__gt: Option<Vec<String>>,
22098    created__gte: Option<Vec<String>>,
22099    created__isnull: Option<bool>,
22100    created__lt: Option<Vec<String>>,
22101    created__lte: Option<Vec<String>>,
22102    created__n: Option<Vec<String>>,
22103    description: Option<Vec<String>>,
22104    description__ic: Option<Vec<String>>,
22105    description__ie: Option<Vec<String>>,
22106    description__iew: Option<Vec<String>>,
22107    description__ire: Option<Vec<String>>,
22108    description__isw: Option<Vec<String>>,
22109    description__n: Option<Vec<String>>,
22110    description__nic: Option<Vec<String>>,
22111    description__nie: Option<Vec<String>>,
22112    description__niew: Option<Vec<String>>,
22113    description__nire: Option<Vec<String>>,
22114    description__nisw: Option<Vec<String>>,
22115    description__nre: Option<Vec<String>>,
22116    description__re: Option<Vec<String>>,
22117    device: Option<Vec<String>>,
22118    device__n: Option<Vec<String>>,
22119    dynamic_groups: Option<Vec<String>>,
22120    dynamic_groups__n: Option<Vec<String>>,
22121    export_targets: Option<Vec<String>>,
22122    export_targets__n: Option<Vec<String>>,
22123    format: Option<&str>,
22124    id: Option<Vec<uuid::Uuid>>,
22125    id__n: Option<Vec<uuid::Uuid>>,
22126    import_targets: Option<Vec<String>>,
22127    import_targets__n: Option<Vec<String>>,
22128    last_updated: Option<Vec<String>>,
22129    last_updated__gt: Option<Vec<String>>,
22130    last_updated__gte: Option<Vec<String>>,
22131    last_updated__isnull: Option<bool>,
22132    last_updated__lt: Option<Vec<String>>,
22133    last_updated__lte: Option<Vec<String>>,
22134    last_updated__n: Option<Vec<String>>,
22135    limit: Option<i32>,
22136    name: Option<Vec<String>>,
22137    name__ic: Option<Vec<String>>,
22138    name__ie: Option<Vec<String>>,
22139    name__iew: Option<Vec<String>>,
22140    name__ire: Option<Vec<String>>,
22141    name__isw: Option<Vec<String>>,
22142    name__n: Option<Vec<String>>,
22143    name__nic: Option<Vec<String>>,
22144    name__nie: Option<Vec<String>>,
22145    name__niew: Option<Vec<String>>,
22146    name__nire: Option<Vec<String>>,
22147    name__nisw: Option<Vec<String>>,
22148    name__nre: Option<Vec<String>>,
22149    name__re: Option<Vec<String>>,
22150    namespace: Option<Vec<String>>,
22151    namespace__n: Option<Vec<String>>,
22152    offset: Option<i32>,
22153    prefix: Option<Vec<String>>,
22154    prefix__n: Option<Vec<String>>,
22155    q: Option<&str>,
22156    rd: Option<Vec<String>>,
22157    rd__ic: Option<Vec<String>>,
22158    rd__ie: Option<Vec<String>>,
22159    rd__iew: Option<Vec<String>>,
22160    rd__ire: Option<Vec<String>>,
22161    rd__isnull: Option<bool>,
22162    rd__isw: Option<Vec<String>>,
22163    rd__n: Option<Vec<String>>,
22164    rd__nic: Option<Vec<String>>,
22165    rd__nie: Option<Vec<String>>,
22166    rd__niew: Option<Vec<String>>,
22167    rd__nire: Option<Vec<String>>,
22168    rd__nisw: Option<Vec<String>>,
22169    rd__nre: Option<Vec<String>>,
22170    rd__re: Option<Vec<String>>,
22171    sort: Option<&str>,
22172    status: Option<Vec<String>>,
22173    status__isnull: Option<bool>,
22174    status__n: Option<Vec<String>>,
22175    tags: Option<Vec<String>>,
22176    tags__isnull: Option<bool>,
22177    tags__n: Option<Vec<String>>,
22178    teams: Option<Vec<String>>,
22179    teams__isnull: Option<bool>,
22180    teams__n: Option<Vec<String>>,
22181    tenant: Option<Vec<String>>,
22182    tenant__isnull: Option<bool>,
22183    tenant__n: Option<Vec<String>>,
22184    tenant_group: Option<Vec<String>>,
22185    tenant_group__isnull: Option<bool>,
22186    tenant_group__n: Option<Vec<String>>,
22187    tenant_id: Option<Vec<uuid::Uuid>>,
22188    tenant_id__isnull: Option<bool>,
22189    tenant_id__n: Option<Vec<uuid::Uuid>>,
22190    virtual_device_contexts: Option<Vec<String>>,
22191    virtual_device_contexts__n: Option<Vec<String>>,
22192    virtual_machines: Option<Vec<String>>,
22193    virtual_machines__n: Option<Vec<String>>,
22194    depth: Option<i32>,
22195    exclude_m2m: Option<bool>,
22196) -> Result<crate::models::PaginatedVrfList, Error<IpamVrfsListError>> {
22197    let local_var_configuration = configuration;
22198
22199    let local_var_client = &local_var_configuration.client;
22200
22201    let local_var_uri_str = format!("{}/ipam/vrfs/", local_var_configuration.base_path);
22202    let mut local_var_req_builder =
22203        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
22204
22205    if let Some(ref local_var_str) = contacts {
22206        local_var_req_builder = match "multi" {
22207            "multi" => local_var_req_builder.query(
22208                &local_var_str
22209                    .into_iter()
22210                    .map(|p| ("contacts".to_owned(), p.to_string()))
22211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22212            ),
22213            _ => local_var_req_builder.query(&[(
22214                "contacts",
22215                &local_var_str
22216                    .into_iter()
22217                    .map(|p| p.to_string())
22218                    .collect::<Vec<String>>()
22219                    .join(",")
22220                    .to_string(),
22221            )]),
22222        };
22223    }
22224    if let Some(ref local_var_str) = contacts__isnull {
22225        local_var_req_builder =
22226            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
22227    }
22228    if let Some(ref local_var_str) = contacts__n {
22229        local_var_req_builder = match "multi" {
22230            "multi" => local_var_req_builder.query(
22231                &local_var_str
22232                    .into_iter()
22233                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
22234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22235            ),
22236            _ => local_var_req_builder.query(&[(
22237                "contacts__n",
22238                &local_var_str
22239                    .into_iter()
22240                    .map(|p| p.to_string())
22241                    .collect::<Vec<String>>()
22242                    .join(",")
22243                    .to_string(),
22244            )]),
22245        };
22246    }
22247    if let Some(ref local_var_str) = created {
22248        local_var_req_builder = match "multi" {
22249            "multi" => local_var_req_builder.query(
22250                &local_var_str
22251                    .into_iter()
22252                    .map(|p| ("created".to_owned(), p.to_string()))
22253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22254            ),
22255            _ => local_var_req_builder.query(&[(
22256                "created",
22257                &local_var_str
22258                    .into_iter()
22259                    .map(|p| p.to_string())
22260                    .collect::<Vec<String>>()
22261                    .join(",")
22262                    .to_string(),
22263            )]),
22264        };
22265    }
22266    if let Some(ref local_var_str) = created__gt {
22267        local_var_req_builder = match "multi" {
22268            "multi" => local_var_req_builder.query(
22269                &local_var_str
22270                    .into_iter()
22271                    .map(|p| ("created__gt".to_owned(), p.to_string()))
22272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22273            ),
22274            _ => local_var_req_builder.query(&[(
22275                "created__gt",
22276                &local_var_str
22277                    .into_iter()
22278                    .map(|p| p.to_string())
22279                    .collect::<Vec<String>>()
22280                    .join(",")
22281                    .to_string(),
22282            )]),
22283        };
22284    }
22285    if let Some(ref local_var_str) = created__gte {
22286        local_var_req_builder = match "multi" {
22287            "multi" => local_var_req_builder.query(
22288                &local_var_str
22289                    .into_iter()
22290                    .map(|p| ("created__gte".to_owned(), p.to_string()))
22291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22292            ),
22293            _ => local_var_req_builder.query(&[(
22294                "created__gte",
22295                &local_var_str
22296                    .into_iter()
22297                    .map(|p| p.to_string())
22298                    .collect::<Vec<String>>()
22299                    .join(",")
22300                    .to_string(),
22301            )]),
22302        };
22303    }
22304    if let Some(ref local_var_str) = created__isnull {
22305        local_var_req_builder =
22306            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
22307    }
22308    if let Some(ref local_var_str) = created__lt {
22309        local_var_req_builder = match "multi" {
22310            "multi" => local_var_req_builder.query(
22311                &local_var_str
22312                    .into_iter()
22313                    .map(|p| ("created__lt".to_owned(), p.to_string()))
22314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22315            ),
22316            _ => local_var_req_builder.query(&[(
22317                "created__lt",
22318                &local_var_str
22319                    .into_iter()
22320                    .map(|p| p.to_string())
22321                    .collect::<Vec<String>>()
22322                    .join(",")
22323                    .to_string(),
22324            )]),
22325        };
22326    }
22327    if let Some(ref local_var_str) = created__lte {
22328        local_var_req_builder = match "multi" {
22329            "multi" => local_var_req_builder.query(
22330                &local_var_str
22331                    .into_iter()
22332                    .map(|p| ("created__lte".to_owned(), p.to_string()))
22333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22334            ),
22335            _ => local_var_req_builder.query(&[(
22336                "created__lte",
22337                &local_var_str
22338                    .into_iter()
22339                    .map(|p| p.to_string())
22340                    .collect::<Vec<String>>()
22341                    .join(",")
22342                    .to_string(),
22343            )]),
22344        };
22345    }
22346    if let Some(ref local_var_str) = created__n {
22347        local_var_req_builder = match "multi" {
22348            "multi" => local_var_req_builder.query(
22349                &local_var_str
22350                    .into_iter()
22351                    .map(|p| ("created__n".to_owned(), p.to_string()))
22352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22353            ),
22354            _ => local_var_req_builder.query(&[(
22355                "created__n",
22356                &local_var_str
22357                    .into_iter()
22358                    .map(|p| p.to_string())
22359                    .collect::<Vec<String>>()
22360                    .join(",")
22361                    .to_string(),
22362            )]),
22363        };
22364    }
22365    if let Some(ref local_var_str) = description {
22366        local_var_req_builder = match "multi" {
22367            "multi" => local_var_req_builder.query(
22368                &local_var_str
22369                    .into_iter()
22370                    .map(|p| ("description".to_owned(), p.to_string()))
22371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22372            ),
22373            _ => local_var_req_builder.query(&[(
22374                "description",
22375                &local_var_str
22376                    .into_iter()
22377                    .map(|p| p.to_string())
22378                    .collect::<Vec<String>>()
22379                    .join(",")
22380                    .to_string(),
22381            )]),
22382        };
22383    }
22384    if let Some(ref local_var_str) = description__ic {
22385        local_var_req_builder = match "multi" {
22386            "multi" => local_var_req_builder.query(
22387                &local_var_str
22388                    .into_iter()
22389                    .map(|p| ("description__ic".to_owned(), p.to_string()))
22390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22391            ),
22392            _ => local_var_req_builder.query(&[(
22393                "description__ic",
22394                &local_var_str
22395                    .into_iter()
22396                    .map(|p| p.to_string())
22397                    .collect::<Vec<String>>()
22398                    .join(",")
22399                    .to_string(),
22400            )]),
22401        };
22402    }
22403    if let Some(ref local_var_str) = description__ie {
22404        local_var_req_builder = match "multi" {
22405            "multi" => local_var_req_builder.query(
22406                &local_var_str
22407                    .into_iter()
22408                    .map(|p| ("description__ie".to_owned(), p.to_string()))
22409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22410            ),
22411            _ => local_var_req_builder.query(&[(
22412                "description__ie",
22413                &local_var_str
22414                    .into_iter()
22415                    .map(|p| p.to_string())
22416                    .collect::<Vec<String>>()
22417                    .join(",")
22418                    .to_string(),
22419            )]),
22420        };
22421    }
22422    if let Some(ref local_var_str) = description__iew {
22423        local_var_req_builder = match "multi" {
22424            "multi" => local_var_req_builder.query(
22425                &local_var_str
22426                    .into_iter()
22427                    .map(|p| ("description__iew".to_owned(), p.to_string()))
22428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22429            ),
22430            _ => local_var_req_builder.query(&[(
22431                "description__iew",
22432                &local_var_str
22433                    .into_iter()
22434                    .map(|p| p.to_string())
22435                    .collect::<Vec<String>>()
22436                    .join(",")
22437                    .to_string(),
22438            )]),
22439        };
22440    }
22441    if let Some(ref local_var_str) = description__ire {
22442        local_var_req_builder = match "multi" {
22443            "multi" => local_var_req_builder.query(
22444                &local_var_str
22445                    .into_iter()
22446                    .map(|p| ("description__ire".to_owned(), p.to_string()))
22447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22448            ),
22449            _ => local_var_req_builder.query(&[(
22450                "description__ire",
22451                &local_var_str
22452                    .into_iter()
22453                    .map(|p| p.to_string())
22454                    .collect::<Vec<String>>()
22455                    .join(",")
22456                    .to_string(),
22457            )]),
22458        };
22459    }
22460    if let Some(ref local_var_str) = description__isw {
22461        local_var_req_builder = match "multi" {
22462            "multi" => local_var_req_builder.query(
22463                &local_var_str
22464                    .into_iter()
22465                    .map(|p| ("description__isw".to_owned(), p.to_string()))
22466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22467            ),
22468            _ => local_var_req_builder.query(&[(
22469                "description__isw",
22470                &local_var_str
22471                    .into_iter()
22472                    .map(|p| p.to_string())
22473                    .collect::<Vec<String>>()
22474                    .join(",")
22475                    .to_string(),
22476            )]),
22477        };
22478    }
22479    if let Some(ref local_var_str) = description__n {
22480        local_var_req_builder = match "multi" {
22481            "multi" => local_var_req_builder.query(
22482                &local_var_str
22483                    .into_iter()
22484                    .map(|p| ("description__n".to_owned(), p.to_string()))
22485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22486            ),
22487            _ => local_var_req_builder.query(&[(
22488                "description__n",
22489                &local_var_str
22490                    .into_iter()
22491                    .map(|p| p.to_string())
22492                    .collect::<Vec<String>>()
22493                    .join(",")
22494                    .to_string(),
22495            )]),
22496        };
22497    }
22498    if let Some(ref local_var_str) = description__nic {
22499        local_var_req_builder = match "multi" {
22500            "multi" => local_var_req_builder.query(
22501                &local_var_str
22502                    .into_iter()
22503                    .map(|p| ("description__nic".to_owned(), p.to_string()))
22504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22505            ),
22506            _ => local_var_req_builder.query(&[(
22507                "description__nic",
22508                &local_var_str
22509                    .into_iter()
22510                    .map(|p| p.to_string())
22511                    .collect::<Vec<String>>()
22512                    .join(",")
22513                    .to_string(),
22514            )]),
22515        };
22516    }
22517    if let Some(ref local_var_str) = description__nie {
22518        local_var_req_builder = match "multi" {
22519            "multi" => local_var_req_builder.query(
22520                &local_var_str
22521                    .into_iter()
22522                    .map(|p| ("description__nie".to_owned(), p.to_string()))
22523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22524            ),
22525            _ => local_var_req_builder.query(&[(
22526                "description__nie",
22527                &local_var_str
22528                    .into_iter()
22529                    .map(|p| p.to_string())
22530                    .collect::<Vec<String>>()
22531                    .join(",")
22532                    .to_string(),
22533            )]),
22534        };
22535    }
22536    if let Some(ref local_var_str) = description__niew {
22537        local_var_req_builder = match "multi" {
22538            "multi" => local_var_req_builder.query(
22539                &local_var_str
22540                    .into_iter()
22541                    .map(|p| ("description__niew".to_owned(), p.to_string()))
22542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22543            ),
22544            _ => local_var_req_builder.query(&[(
22545                "description__niew",
22546                &local_var_str
22547                    .into_iter()
22548                    .map(|p| p.to_string())
22549                    .collect::<Vec<String>>()
22550                    .join(",")
22551                    .to_string(),
22552            )]),
22553        };
22554    }
22555    if let Some(ref local_var_str) = description__nire {
22556        local_var_req_builder = match "multi" {
22557            "multi" => local_var_req_builder.query(
22558                &local_var_str
22559                    .into_iter()
22560                    .map(|p| ("description__nire".to_owned(), p.to_string()))
22561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22562            ),
22563            _ => local_var_req_builder.query(&[(
22564                "description__nire",
22565                &local_var_str
22566                    .into_iter()
22567                    .map(|p| p.to_string())
22568                    .collect::<Vec<String>>()
22569                    .join(",")
22570                    .to_string(),
22571            )]),
22572        };
22573    }
22574    if let Some(ref local_var_str) = description__nisw {
22575        local_var_req_builder = match "multi" {
22576            "multi" => local_var_req_builder.query(
22577                &local_var_str
22578                    .into_iter()
22579                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
22580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22581            ),
22582            _ => local_var_req_builder.query(&[(
22583                "description__nisw",
22584                &local_var_str
22585                    .into_iter()
22586                    .map(|p| p.to_string())
22587                    .collect::<Vec<String>>()
22588                    .join(",")
22589                    .to_string(),
22590            )]),
22591        };
22592    }
22593    if let Some(ref local_var_str) = description__nre {
22594        local_var_req_builder = match "multi" {
22595            "multi" => local_var_req_builder.query(
22596                &local_var_str
22597                    .into_iter()
22598                    .map(|p| ("description__nre".to_owned(), p.to_string()))
22599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22600            ),
22601            _ => local_var_req_builder.query(&[(
22602                "description__nre",
22603                &local_var_str
22604                    .into_iter()
22605                    .map(|p| p.to_string())
22606                    .collect::<Vec<String>>()
22607                    .join(",")
22608                    .to_string(),
22609            )]),
22610        };
22611    }
22612    if let Some(ref local_var_str) = description__re {
22613        local_var_req_builder = match "multi" {
22614            "multi" => local_var_req_builder.query(
22615                &local_var_str
22616                    .into_iter()
22617                    .map(|p| ("description__re".to_owned(), p.to_string()))
22618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22619            ),
22620            _ => local_var_req_builder.query(&[(
22621                "description__re",
22622                &local_var_str
22623                    .into_iter()
22624                    .map(|p| p.to_string())
22625                    .collect::<Vec<String>>()
22626                    .join(",")
22627                    .to_string(),
22628            )]),
22629        };
22630    }
22631    if let Some(ref local_var_str) = device {
22632        local_var_req_builder = match "multi" {
22633            "multi" => local_var_req_builder.query(
22634                &local_var_str
22635                    .into_iter()
22636                    .map(|p| ("device".to_owned(), p.to_string()))
22637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22638            ),
22639            _ => local_var_req_builder.query(&[(
22640                "device",
22641                &local_var_str
22642                    .into_iter()
22643                    .map(|p| p.to_string())
22644                    .collect::<Vec<String>>()
22645                    .join(",")
22646                    .to_string(),
22647            )]),
22648        };
22649    }
22650    if let Some(ref local_var_str) = device__n {
22651        local_var_req_builder = match "multi" {
22652            "multi" => local_var_req_builder.query(
22653                &local_var_str
22654                    .into_iter()
22655                    .map(|p| ("device__n".to_owned(), p.to_string()))
22656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22657            ),
22658            _ => local_var_req_builder.query(&[(
22659                "device__n",
22660                &local_var_str
22661                    .into_iter()
22662                    .map(|p| p.to_string())
22663                    .collect::<Vec<String>>()
22664                    .join(",")
22665                    .to_string(),
22666            )]),
22667        };
22668    }
22669    if let Some(ref local_var_str) = dynamic_groups {
22670        local_var_req_builder = match "multi" {
22671            "multi" => local_var_req_builder.query(
22672                &local_var_str
22673                    .into_iter()
22674                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
22675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22676            ),
22677            _ => local_var_req_builder.query(&[(
22678                "dynamic_groups",
22679                &local_var_str
22680                    .into_iter()
22681                    .map(|p| p.to_string())
22682                    .collect::<Vec<String>>()
22683                    .join(",")
22684                    .to_string(),
22685            )]),
22686        };
22687    }
22688    if let Some(ref local_var_str) = dynamic_groups__n {
22689        local_var_req_builder = match "multi" {
22690            "multi" => local_var_req_builder.query(
22691                &local_var_str
22692                    .into_iter()
22693                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
22694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22695            ),
22696            _ => local_var_req_builder.query(&[(
22697                "dynamic_groups__n",
22698                &local_var_str
22699                    .into_iter()
22700                    .map(|p| p.to_string())
22701                    .collect::<Vec<String>>()
22702                    .join(",")
22703                    .to_string(),
22704            )]),
22705        };
22706    }
22707    if let Some(ref local_var_str) = export_targets {
22708        local_var_req_builder = match "multi" {
22709            "multi" => local_var_req_builder.query(
22710                &local_var_str
22711                    .into_iter()
22712                    .map(|p| ("export_targets".to_owned(), p.to_string()))
22713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22714            ),
22715            _ => local_var_req_builder.query(&[(
22716                "export_targets",
22717                &local_var_str
22718                    .into_iter()
22719                    .map(|p| p.to_string())
22720                    .collect::<Vec<String>>()
22721                    .join(",")
22722                    .to_string(),
22723            )]),
22724        };
22725    }
22726    if let Some(ref local_var_str) = export_targets__n {
22727        local_var_req_builder = match "multi" {
22728            "multi" => local_var_req_builder.query(
22729                &local_var_str
22730                    .into_iter()
22731                    .map(|p| ("export_targets__n".to_owned(), p.to_string()))
22732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22733            ),
22734            _ => local_var_req_builder.query(&[(
22735                "export_targets__n",
22736                &local_var_str
22737                    .into_iter()
22738                    .map(|p| p.to_string())
22739                    .collect::<Vec<String>>()
22740                    .join(",")
22741                    .to_string(),
22742            )]),
22743        };
22744    }
22745    if let Some(ref local_var_str) = format {
22746        local_var_req_builder =
22747            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
22748    }
22749    if let Some(ref local_var_str) = id {
22750        local_var_req_builder = match "multi" {
22751            "multi" => local_var_req_builder.query(
22752                &local_var_str
22753                    .into_iter()
22754                    .map(|p| ("id".to_owned(), p.to_string()))
22755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22756            ),
22757            _ => local_var_req_builder.query(&[(
22758                "id",
22759                &local_var_str
22760                    .into_iter()
22761                    .map(|p| p.to_string())
22762                    .collect::<Vec<String>>()
22763                    .join(",")
22764                    .to_string(),
22765            )]),
22766        };
22767    }
22768    if let Some(ref local_var_str) = id__n {
22769        local_var_req_builder = match "multi" {
22770            "multi" => local_var_req_builder.query(
22771                &local_var_str
22772                    .into_iter()
22773                    .map(|p| ("id__n".to_owned(), p.to_string()))
22774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22775            ),
22776            _ => local_var_req_builder.query(&[(
22777                "id__n",
22778                &local_var_str
22779                    .into_iter()
22780                    .map(|p| p.to_string())
22781                    .collect::<Vec<String>>()
22782                    .join(",")
22783                    .to_string(),
22784            )]),
22785        };
22786    }
22787    if let Some(ref local_var_str) = import_targets {
22788        local_var_req_builder = match "multi" {
22789            "multi" => local_var_req_builder.query(
22790                &local_var_str
22791                    .into_iter()
22792                    .map(|p| ("import_targets".to_owned(), p.to_string()))
22793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22794            ),
22795            _ => local_var_req_builder.query(&[(
22796                "import_targets",
22797                &local_var_str
22798                    .into_iter()
22799                    .map(|p| p.to_string())
22800                    .collect::<Vec<String>>()
22801                    .join(",")
22802                    .to_string(),
22803            )]),
22804        };
22805    }
22806    if let Some(ref local_var_str) = import_targets__n {
22807        local_var_req_builder = match "multi" {
22808            "multi" => local_var_req_builder.query(
22809                &local_var_str
22810                    .into_iter()
22811                    .map(|p| ("import_targets__n".to_owned(), p.to_string()))
22812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22813            ),
22814            _ => local_var_req_builder.query(&[(
22815                "import_targets__n",
22816                &local_var_str
22817                    .into_iter()
22818                    .map(|p| p.to_string())
22819                    .collect::<Vec<String>>()
22820                    .join(",")
22821                    .to_string(),
22822            )]),
22823        };
22824    }
22825    if let Some(ref local_var_str) = last_updated {
22826        local_var_req_builder = match "multi" {
22827            "multi" => local_var_req_builder.query(
22828                &local_var_str
22829                    .into_iter()
22830                    .map(|p| ("last_updated".to_owned(), p.to_string()))
22831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22832            ),
22833            _ => local_var_req_builder.query(&[(
22834                "last_updated",
22835                &local_var_str
22836                    .into_iter()
22837                    .map(|p| p.to_string())
22838                    .collect::<Vec<String>>()
22839                    .join(",")
22840                    .to_string(),
22841            )]),
22842        };
22843    }
22844    if let Some(ref local_var_str) = last_updated__gt {
22845        local_var_req_builder = match "multi" {
22846            "multi" => local_var_req_builder.query(
22847                &local_var_str
22848                    .into_iter()
22849                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
22850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22851            ),
22852            _ => local_var_req_builder.query(&[(
22853                "last_updated__gt",
22854                &local_var_str
22855                    .into_iter()
22856                    .map(|p| p.to_string())
22857                    .collect::<Vec<String>>()
22858                    .join(",")
22859                    .to_string(),
22860            )]),
22861        };
22862    }
22863    if let Some(ref local_var_str) = last_updated__gte {
22864        local_var_req_builder = match "multi" {
22865            "multi" => local_var_req_builder.query(
22866                &local_var_str
22867                    .into_iter()
22868                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
22869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22870            ),
22871            _ => local_var_req_builder.query(&[(
22872                "last_updated__gte",
22873                &local_var_str
22874                    .into_iter()
22875                    .map(|p| p.to_string())
22876                    .collect::<Vec<String>>()
22877                    .join(",")
22878                    .to_string(),
22879            )]),
22880        };
22881    }
22882    if let Some(ref local_var_str) = last_updated__isnull {
22883        local_var_req_builder =
22884            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
22885    }
22886    if let Some(ref local_var_str) = last_updated__lt {
22887        local_var_req_builder = match "multi" {
22888            "multi" => local_var_req_builder.query(
22889                &local_var_str
22890                    .into_iter()
22891                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
22892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22893            ),
22894            _ => local_var_req_builder.query(&[(
22895                "last_updated__lt",
22896                &local_var_str
22897                    .into_iter()
22898                    .map(|p| p.to_string())
22899                    .collect::<Vec<String>>()
22900                    .join(",")
22901                    .to_string(),
22902            )]),
22903        };
22904    }
22905    if let Some(ref local_var_str) = last_updated__lte {
22906        local_var_req_builder = match "multi" {
22907            "multi" => local_var_req_builder.query(
22908                &local_var_str
22909                    .into_iter()
22910                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
22911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22912            ),
22913            _ => local_var_req_builder.query(&[(
22914                "last_updated__lte",
22915                &local_var_str
22916                    .into_iter()
22917                    .map(|p| p.to_string())
22918                    .collect::<Vec<String>>()
22919                    .join(",")
22920                    .to_string(),
22921            )]),
22922        };
22923    }
22924    if let Some(ref local_var_str) = last_updated__n {
22925        local_var_req_builder = match "multi" {
22926            "multi" => local_var_req_builder.query(
22927                &local_var_str
22928                    .into_iter()
22929                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
22930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22931            ),
22932            _ => local_var_req_builder.query(&[(
22933                "last_updated__n",
22934                &local_var_str
22935                    .into_iter()
22936                    .map(|p| p.to_string())
22937                    .collect::<Vec<String>>()
22938                    .join(",")
22939                    .to_string(),
22940            )]),
22941        };
22942    }
22943    if let Some(ref local_var_str) = limit {
22944        local_var_req_builder =
22945            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
22946    }
22947    if let Some(ref local_var_str) = name {
22948        local_var_req_builder = match "multi" {
22949            "multi" => local_var_req_builder.query(
22950                &local_var_str
22951                    .into_iter()
22952                    .map(|p| ("name".to_owned(), p.to_string()))
22953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22954            ),
22955            _ => local_var_req_builder.query(&[(
22956                "name",
22957                &local_var_str
22958                    .into_iter()
22959                    .map(|p| p.to_string())
22960                    .collect::<Vec<String>>()
22961                    .join(",")
22962                    .to_string(),
22963            )]),
22964        };
22965    }
22966    if let Some(ref local_var_str) = name__ic {
22967        local_var_req_builder = match "multi" {
22968            "multi" => local_var_req_builder.query(
22969                &local_var_str
22970                    .into_iter()
22971                    .map(|p| ("name__ic".to_owned(), p.to_string()))
22972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22973            ),
22974            _ => local_var_req_builder.query(&[(
22975                "name__ic",
22976                &local_var_str
22977                    .into_iter()
22978                    .map(|p| p.to_string())
22979                    .collect::<Vec<String>>()
22980                    .join(",")
22981                    .to_string(),
22982            )]),
22983        };
22984    }
22985    if let Some(ref local_var_str) = name__ie {
22986        local_var_req_builder = match "multi" {
22987            "multi" => local_var_req_builder.query(
22988                &local_var_str
22989                    .into_iter()
22990                    .map(|p| ("name__ie".to_owned(), p.to_string()))
22991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22992            ),
22993            _ => local_var_req_builder.query(&[(
22994                "name__ie",
22995                &local_var_str
22996                    .into_iter()
22997                    .map(|p| p.to_string())
22998                    .collect::<Vec<String>>()
22999                    .join(",")
23000                    .to_string(),
23001            )]),
23002        };
23003    }
23004    if let Some(ref local_var_str) = name__iew {
23005        local_var_req_builder = match "multi" {
23006            "multi" => local_var_req_builder.query(
23007                &local_var_str
23008                    .into_iter()
23009                    .map(|p| ("name__iew".to_owned(), p.to_string()))
23010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23011            ),
23012            _ => local_var_req_builder.query(&[(
23013                "name__iew",
23014                &local_var_str
23015                    .into_iter()
23016                    .map(|p| p.to_string())
23017                    .collect::<Vec<String>>()
23018                    .join(",")
23019                    .to_string(),
23020            )]),
23021        };
23022    }
23023    if let Some(ref local_var_str) = name__ire {
23024        local_var_req_builder = match "multi" {
23025            "multi" => local_var_req_builder.query(
23026                &local_var_str
23027                    .into_iter()
23028                    .map(|p| ("name__ire".to_owned(), p.to_string()))
23029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23030            ),
23031            _ => local_var_req_builder.query(&[(
23032                "name__ire",
23033                &local_var_str
23034                    .into_iter()
23035                    .map(|p| p.to_string())
23036                    .collect::<Vec<String>>()
23037                    .join(",")
23038                    .to_string(),
23039            )]),
23040        };
23041    }
23042    if let Some(ref local_var_str) = name__isw {
23043        local_var_req_builder = match "multi" {
23044            "multi" => local_var_req_builder.query(
23045                &local_var_str
23046                    .into_iter()
23047                    .map(|p| ("name__isw".to_owned(), p.to_string()))
23048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23049            ),
23050            _ => local_var_req_builder.query(&[(
23051                "name__isw",
23052                &local_var_str
23053                    .into_iter()
23054                    .map(|p| p.to_string())
23055                    .collect::<Vec<String>>()
23056                    .join(",")
23057                    .to_string(),
23058            )]),
23059        };
23060    }
23061    if let Some(ref local_var_str) = name__n {
23062        local_var_req_builder = match "multi" {
23063            "multi" => local_var_req_builder.query(
23064                &local_var_str
23065                    .into_iter()
23066                    .map(|p| ("name__n".to_owned(), p.to_string()))
23067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23068            ),
23069            _ => local_var_req_builder.query(&[(
23070                "name__n",
23071                &local_var_str
23072                    .into_iter()
23073                    .map(|p| p.to_string())
23074                    .collect::<Vec<String>>()
23075                    .join(",")
23076                    .to_string(),
23077            )]),
23078        };
23079    }
23080    if let Some(ref local_var_str) = name__nic {
23081        local_var_req_builder = match "multi" {
23082            "multi" => local_var_req_builder.query(
23083                &local_var_str
23084                    .into_iter()
23085                    .map(|p| ("name__nic".to_owned(), p.to_string()))
23086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23087            ),
23088            _ => local_var_req_builder.query(&[(
23089                "name__nic",
23090                &local_var_str
23091                    .into_iter()
23092                    .map(|p| p.to_string())
23093                    .collect::<Vec<String>>()
23094                    .join(",")
23095                    .to_string(),
23096            )]),
23097        };
23098    }
23099    if let Some(ref local_var_str) = name__nie {
23100        local_var_req_builder = match "multi" {
23101            "multi" => local_var_req_builder.query(
23102                &local_var_str
23103                    .into_iter()
23104                    .map(|p| ("name__nie".to_owned(), p.to_string()))
23105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23106            ),
23107            _ => local_var_req_builder.query(&[(
23108                "name__nie",
23109                &local_var_str
23110                    .into_iter()
23111                    .map(|p| p.to_string())
23112                    .collect::<Vec<String>>()
23113                    .join(",")
23114                    .to_string(),
23115            )]),
23116        };
23117    }
23118    if let Some(ref local_var_str) = name__niew {
23119        local_var_req_builder = match "multi" {
23120            "multi" => local_var_req_builder.query(
23121                &local_var_str
23122                    .into_iter()
23123                    .map(|p| ("name__niew".to_owned(), p.to_string()))
23124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23125            ),
23126            _ => local_var_req_builder.query(&[(
23127                "name__niew",
23128                &local_var_str
23129                    .into_iter()
23130                    .map(|p| p.to_string())
23131                    .collect::<Vec<String>>()
23132                    .join(",")
23133                    .to_string(),
23134            )]),
23135        };
23136    }
23137    if let Some(ref local_var_str) = name__nire {
23138        local_var_req_builder = match "multi" {
23139            "multi" => local_var_req_builder.query(
23140                &local_var_str
23141                    .into_iter()
23142                    .map(|p| ("name__nire".to_owned(), p.to_string()))
23143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23144            ),
23145            _ => local_var_req_builder.query(&[(
23146                "name__nire",
23147                &local_var_str
23148                    .into_iter()
23149                    .map(|p| p.to_string())
23150                    .collect::<Vec<String>>()
23151                    .join(",")
23152                    .to_string(),
23153            )]),
23154        };
23155    }
23156    if let Some(ref local_var_str) = name__nisw {
23157        local_var_req_builder = match "multi" {
23158            "multi" => local_var_req_builder.query(
23159                &local_var_str
23160                    .into_iter()
23161                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
23162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23163            ),
23164            _ => local_var_req_builder.query(&[(
23165                "name__nisw",
23166                &local_var_str
23167                    .into_iter()
23168                    .map(|p| p.to_string())
23169                    .collect::<Vec<String>>()
23170                    .join(",")
23171                    .to_string(),
23172            )]),
23173        };
23174    }
23175    if let Some(ref local_var_str) = name__nre {
23176        local_var_req_builder = match "multi" {
23177            "multi" => local_var_req_builder.query(
23178                &local_var_str
23179                    .into_iter()
23180                    .map(|p| ("name__nre".to_owned(), p.to_string()))
23181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23182            ),
23183            _ => local_var_req_builder.query(&[(
23184                "name__nre",
23185                &local_var_str
23186                    .into_iter()
23187                    .map(|p| p.to_string())
23188                    .collect::<Vec<String>>()
23189                    .join(",")
23190                    .to_string(),
23191            )]),
23192        };
23193    }
23194    if let Some(ref local_var_str) = name__re {
23195        local_var_req_builder = match "multi" {
23196            "multi" => local_var_req_builder.query(
23197                &local_var_str
23198                    .into_iter()
23199                    .map(|p| ("name__re".to_owned(), p.to_string()))
23200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23201            ),
23202            _ => local_var_req_builder.query(&[(
23203                "name__re",
23204                &local_var_str
23205                    .into_iter()
23206                    .map(|p| p.to_string())
23207                    .collect::<Vec<String>>()
23208                    .join(",")
23209                    .to_string(),
23210            )]),
23211        };
23212    }
23213    if let Some(ref local_var_str) = namespace {
23214        local_var_req_builder = match "multi" {
23215            "multi" => local_var_req_builder.query(
23216                &local_var_str
23217                    .into_iter()
23218                    .map(|p| ("namespace".to_owned(), p.to_string()))
23219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23220            ),
23221            _ => local_var_req_builder.query(&[(
23222                "namespace",
23223                &local_var_str
23224                    .into_iter()
23225                    .map(|p| p.to_string())
23226                    .collect::<Vec<String>>()
23227                    .join(",")
23228                    .to_string(),
23229            )]),
23230        };
23231    }
23232    if let Some(ref local_var_str) = namespace__n {
23233        local_var_req_builder = match "multi" {
23234            "multi" => local_var_req_builder.query(
23235                &local_var_str
23236                    .into_iter()
23237                    .map(|p| ("namespace__n".to_owned(), p.to_string()))
23238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23239            ),
23240            _ => local_var_req_builder.query(&[(
23241                "namespace__n",
23242                &local_var_str
23243                    .into_iter()
23244                    .map(|p| p.to_string())
23245                    .collect::<Vec<String>>()
23246                    .join(",")
23247                    .to_string(),
23248            )]),
23249        };
23250    }
23251    if let Some(ref local_var_str) = offset {
23252        local_var_req_builder =
23253            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
23254    }
23255    if let Some(ref local_var_str) = prefix {
23256        local_var_req_builder = match "multi" {
23257            "multi" => local_var_req_builder.query(
23258                &local_var_str
23259                    .into_iter()
23260                    .map(|p| ("prefix".to_owned(), p.to_string()))
23261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23262            ),
23263            _ => local_var_req_builder.query(&[(
23264                "prefix",
23265                &local_var_str
23266                    .into_iter()
23267                    .map(|p| p.to_string())
23268                    .collect::<Vec<String>>()
23269                    .join(",")
23270                    .to_string(),
23271            )]),
23272        };
23273    }
23274    if let Some(ref local_var_str) = prefix__n {
23275        local_var_req_builder = match "multi" {
23276            "multi" => local_var_req_builder.query(
23277                &local_var_str
23278                    .into_iter()
23279                    .map(|p| ("prefix__n".to_owned(), p.to_string()))
23280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23281            ),
23282            _ => local_var_req_builder.query(&[(
23283                "prefix__n",
23284                &local_var_str
23285                    .into_iter()
23286                    .map(|p| p.to_string())
23287                    .collect::<Vec<String>>()
23288                    .join(",")
23289                    .to_string(),
23290            )]),
23291        };
23292    }
23293    if let Some(ref local_var_str) = q {
23294        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
23295    }
23296    if let Some(ref local_var_str) = rd {
23297        local_var_req_builder = match "multi" {
23298            "multi" => local_var_req_builder.query(
23299                &local_var_str
23300                    .into_iter()
23301                    .map(|p| ("rd".to_owned(), p.to_string()))
23302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23303            ),
23304            _ => local_var_req_builder.query(&[(
23305                "rd",
23306                &local_var_str
23307                    .into_iter()
23308                    .map(|p| p.to_string())
23309                    .collect::<Vec<String>>()
23310                    .join(",")
23311                    .to_string(),
23312            )]),
23313        };
23314    }
23315    if let Some(ref local_var_str) = rd__ic {
23316        local_var_req_builder = match "multi" {
23317            "multi" => local_var_req_builder.query(
23318                &local_var_str
23319                    .into_iter()
23320                    .map(|p| ("rd__ic".to_owned(), p.to_string()))
23321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23322            ),
23323            _ => local_var_req_builder.query(&[(
23324                "rd__ic",
23325                &local_var_str
23326                    .into_iter()
23327                    .map(|p| p.to_string())
23328                    .collect::<Vec<String>>()
23329                    .join(",")
23330                    .to_string(),
23331            )]),
23332        };
23333    }
23334    if let Some(ref local_var_str) = rd__ie {
23335        local_var_req_builder = match "multi" {
23336            "multi" => local_var_req_builder.query(
23337                &local_var_str
23338                    .into_iter()
23339                    .map(|p| ("rd__ie".to_owned(), p.to_string()))
23340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23341            ),
23342            _ => local_var_req_builder.query(&[(
23343                "rd__ie",
23344                &local_var_str
23345                    .into_iter()
23346                    .map(|p| p.to_string())
23347                    .collect::<Vec<String>>()
23348                    .join(",")
23349                    .to_string(),
23350            )]),
23351        };
23352    }
23353    if let Some(ref local_var_str) = rd__iew {
23354        local_var_req_builder = match "multi" {
23355            "multi" => local_var_req_builder.query(
23356                &local_var_str
23357                    .into_iter()
23358                    .map(|p| ("rd__iew".to_owned(), p.to_string()))
23359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23360            ),
23361            _ => local_var_req_builder.query(&[(
23362                "rd__iew",
23363                &local_var_str
23364                    .into_iter()
23365                    .map(|p| p.to_string())
23366                    .collect::<Vec<String>>()
23367                    .join(",")
23368                    .to_string(),
23369            )]),
23370        };
23371    }
23372    if let Some(ref local_var_str) = rd__ire {
23373        local_var_req_builder = match "multi" {
23374            "multi" => local_var_req_builder.query(
23375                &local_var_str
23376                    .into_iter()
23377                    .map(|p| ("rd__ire".to_owned(), p.to_string()))
23378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23379            ),
23380            _ => local_var_req_builder.query(&[(
23381                "rd__ire",
23382                &local_var_str
23383                    .into_iter()
23384                    .map(|p| p.to_string())
23385                    .collect::<Vec<String>>()
23386                    .join(",")
23387                    .to_string(),
23388            )]),
23389        };
23390    }
23391    if let Some(ref local_var_str) = rd__isnull {
23392        local_var_req_builder =
23393            local_var_req_builder.query(&[("rd__isnull", &local_var_str.to_string())]);
23394    }
23395    if let Some(ref local_var_str) = rd__isw {
23396        local_var_req_builder = match "multi" {
23397            "multi" => local_var_req_builder.query(
23398                &local_var_str
23399                    .into_iter()
23400                    .map(|p| ("rd__isw".to_owned(), p.to_string()))
23401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23402            ),
23403            _ => local_var_req_builder.query(&[(
23404                "rd__isw",
23405                &local_var_str
23406                    .into_iter()
23407                    .map(|p| p.to_string())
23408                    .collect::<Vec<String>>()
23409                    .join(",")
23410                    .to_string(),
23411            )]),
23412        };
23413    }
23414    if let Some(ref local_var_str) = rd__n {
23415        local_var_req_builder = match "multi" {
23416            "multi" => local_var_req_builder.query(
23417                &local_var_str
23418                    .into_iter()
23419                    .map(|p| ("rd__n".to_owned(), p.to_string()))
23420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23421            ),
23422            _ => local_var_req_builder.query(&[(
23423                "rd__n",
23424                &local_var_str
23425                    .into_iter()
23426                    .map(|p| p.to_string())
23427                    .collect::<Vec<String>>()
23428                    .join(",")
23429                    .to_string(),
23430            )]),
23431        };
23432    }
23433    if let Some(ref local_var_str) = rd__nic {
23434        local_var_req_builder = match "multi" {
23435            "multi" => local_var_req_builder.query(
23436                &local_var_str
23437                    .into_iter()
23438                    .map(|p| ("rd__nic".to_owned(), p.to_string()))
23439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23440            ),
23441            _ => local_var_req_builder.query(&[(
23442                "rd__nic",
23443                &local_var_str
23444                    .into_iter()
23445                    .map(|p| p.to_string())
23446                    .collect::<Vec<String>>()
23447                    .join(",")
23448                    .to_string(),
23449            )]),
23450        };
23451    }
23452    if let Some(ref local_var_str) = rd__nie {
23453        local_var_req_builder = match "multi" {
23454            "multi" => local_var_req_builder.query(
23455                &local_var_str
23456                    .into_iter()
23457                    .map(|p| ("rd__nie".to_owned(), p.to_string()))
23458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23459            ),
23460            _ => local_var_req_builder.query(&[(
23461                "rd__nie",
23462                &local_var_str
23463                    .into_iter()
23464                    .map(|p| p.to_string())
23465                    .collect::<Vec<String>>()
23466                    .join(",")
23467                    .to_string(),
23468            )]),
23469        };
23470    }
23471    if let Some(ref local_var_str) = rd__niew {
23472        local_var_req_builder = match "multi" {
23473            "multi" => local_var_req_builder.query(
23474                &local_var_str
23475                    .into_iter()
23476                    .map(|p| ("rd__niew".to_owned(), p.to_string()))
23477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23478            ),
23479            _ => local_var_req_builder.query(&[(
23480                "rd__niew",
23481                &local_var_str
23482                    .into_iter()
23483                    .map(|p| p.to_string())
23484                    .collect::<Vec<String>>()
23485                    .join(",")
23486                    .to_string(),
23487            )]),
23488        };
23489    }
23490    if let Some(ref local_var_str) = rd__nire {
23491        local_var_req_builder = match "multi" {
23492            "multi" => local_var_req_builder.query(
23493                &local_var_str
23494                    .into_iter()
23495                    .map(|p| ("rd__nire".to_owned(), p.to_string()))
23496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23497            ),
23498            _ => local_var_req_builder.query(&[(
23499                "rd__nire",
23500                &local_var_str
23501                    .into_iter()
23502                    .map(|p| p.to_string())
23503                    .collect::<Vec<String>>()
23504                    .join(",")
23505                    .to_string(),
23506            )]),
23507        };
23508    }
23509    if let Some(ref local_var_str) = rd__nisw {
23510        local_var_req_builder = match "multi" {
23511            "multi" => local_var_req_builder.query(
23512                &local_var_str
23513                    .into_iter()
23514                    .map(|p| ("rd__nisw".to_owned(), p.to_string()))
23515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23516            ),
23517            _ => local_var_req_builder.query(&[(
23518                "rd__nisw",
23519                &local_var_str
23520                    .into_iter()
23521                    .map(|p| p.to_string())
23522                    .collect::<Vec<String>>()
23523                    .join(",")
23524                    .to_string(),
23525            )]),
23526        };
23527    }
23528    if let Some(ref local_var_str) = rd__nre {
23529        local_var_req_builder = match "multi" {
23530            "multi" => local_var_req_builder.query(
23531                &local_var_str
23532                    .into_iter()
23533                    .map(|p| ("rd__nre".to_owned(), p.to_string()))
23534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23535            ),
23536            _ => local_var_req_builder.query(&[(
23537                "rd__nre",
23538                &local_var_str
23539                    .into_iter()
23540                    .map(|p| p.to_string())
23541                    .collect::<Vec<String>>()
23542                    .join(",")
23543                    .to_string(),
23544            )]),
23545        };
23546    }
23547    if let Some(ref local_var_str) = rd__re {
23548        local_var_req_builder = match "multi" {
23549            "multi" => local_var_req_builder.query(
23550                &local_var_str
23551                    .into_iter()
23552                    .map(|p| ("rd__re".to_owned(), p.to_string()))
23553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23554            ),
23555            _ => local_var_req_builder.query(&[(
23556                "rd__re",
23557                &local_var_str
23558                    .into_iter()
23559                    .map(|p| p.to_string())
23560                    .collect::<Vec<String>>()
23561                    .join(",")
23562                    .to_string(),
23563            )]),
23564        };
23565    }
23566    if let Some(ref local_var_str) = sort {
23567        local_var_req_builder =
23568            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
23569    }
23570    if let Some(ref local_var_str) = status {
23571        local_var_req_builder = match "multi" {
23572            "multi" => local_var_req_builder.query(
23573                &local_var_str
23574                    .into_iter()
23575                    .map(|p| ("status".to_owned(), p.to_string()))
23576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23577            ),
23578            _ => local_var_req_builder.query(&[(
23579                "status",
23580                &local_var_str
23581                    .into_iter()
23582                    .map(|p| p.to_string())
23583                    .collect::<Vec<String>>()
23584                    .join(",")
23585                    .to_string(),
23586            )]),
23587        };
23588    }
23589    if let Some(ref local_var_str) = status__isnull {
23590        local_var_req_builder =
23591            local_var_req_builder.query(&[("status__isnull", &local_var_str.to_string())]);
23592    }
23593    if let Some(ref local_var_str) = status__n {
23594        local_var_req_builder = match "multi" {
23595            "multi" => local_var_req_builder.query(
23596                &local_var_str
23597                    .into_iter()
23598                    .map(|p| ("status__n".to_owned(), p.to_string()))
23599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23600            ),
23601            _ => local_var_req_builder.query(&[(
23602                "status__n",
23603                &local_var_str
23604                    .into_iter()
23605                    .map(|p| p.to_string())
23606                    .collect::<Vec<String>>()
23607                    .join(",")
23608                    .to_string(),
23609            )]),
23610        };
23611    }
23612    if let Some(ref local_var_str) = tags {
23613        local_var_req_builder = match "multi" {
23614            "multi" => local_var_req_builder.query(
23615                &local_var_str
23616                    .into_iter()
23617                    .map(|p| ("tags".to_owned(), p.to_string()))
23618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23619            ),
23620            _ => local_var_req_builder.query(&[(
23621                "tags",
23622                &local_var_str
23623                    .into_iter()
23624                    .map(|p| p.to_string())
23625                    .collect::<Vec<String>>()
23626                    .join(",")
23627                    .to_string(),
23628            )]),
23629        };
23630    }
23631    if let Some(ref local_var_str) = tags__isnull {
23632        local_var_req_builder =
23633            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
23634    }
23635    if let Some(ref local_var_str) = tags__n {
23636        local_var_req_builder = match "multi" {
23637            "multi" => local_var_req_builder.query(
23638                &local_var_str
23639                    .into_iter()
23640                    .map(|p| ("tags__n".to_owned(), p.to_string()))
23641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23642            ),
23643            _ => local_var_req_builder.query(&[(
23644                "tags__n",
23645                &local_var_str
23646                    .into_iter()
23647                    .map(|p| p.to_string())
23648                    .collect::<Vec<String>>()
23649                    .join(",")
23650                    .to_string(),
23651            )]),
23652        };
23653    }
23654    if let Some(ref local_var_str) = teams {
23655        local_var_req_builder = match "multi" {
23656            "multi" => local_var_req_builder.query(
23657                &local_var_str
23658                    .into_iter()
23659                    .map(|p| ("teams".to_owned(), p.to_string()))
23660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23661            ),
23662            _ => local_var_req_builder.query(&[(
23663                "teams",
23664                &local_var_str
23665                    .into_iter()
23666                    .map(|p| p.to_string())
23667                    .collect::<Vec<String>>()
23668                    .join(",")
23669                    .to_string(),
23670            )]),
23671        };
23672    }
23673    if let Some(ref local_var_str) = teams__isnull {
23674        local_var_req_builder =
23675            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
23676    }
23677    if let Some(ref local_var_str) = teams__n {
23678        local_var_req_builder = match "multi" {
23679            "multi" => local_var_req_builder.query(
23680                &local_var_str
23681                    .into_iter()
23682                    .map(|p| ("teams__n".to_owned(), p.to_string()))
23683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23684            ),
23685            _ => local_var_req_builder.query(&[(
23686                "teams__n",
23687                &local_var_str
23688                    .into_iter()
23689                    .map(|p| p.to_string())
23690                    .collect::<Vec<String>>()
23691                    .join(",")
23692                    .to_string(),
23693            )]),
23694        };
23695    }
23696    if let Some(ref local_var_str) = tenant {
23697        local_var_req_builder = match "multi" {
23698            "multi" => local_var_req_builder.query(
23699                &local_var_str
23700                    .into_iter()
23701                    .map(|p| ("tenant".to_owned(), p.to_string()))
23702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23703            ),
23704            _ => local_var_req_builder.query(&[(
23705                "tenant",
23706                &local_var_str
23707                    .into_iter()
23708                    .map(|p| p.to_string())
23709                    .collect::<Vec<String>>()
23710                    .join(",")
23711                    .to_string(),
23712            )]),
23713        };
23714    }
23715    if let Some(ref local_var_str) = tenant__isnull {
23716        local_var_req_builder =
23717            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
23718    }
23719    if let Some(ref local_var_str) = tenant__n {
23720        local_var_req_builder = match "multi" {
23721            "multi" => local_var_req_builder.query(
23722                &local_var_str
23723                    .into_iter()
23724                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
23725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23726            ),
23727            _ => local_var_req_builder.query(&[(
23728                "tenant__n",
23729                &local_var_str
23730                    .into_iter()
23731                    .map(|p| p.to_string())
23732                    .collect::<Vec<String>>()
23733                    .join(",")
23734                    .to_string(),
23735            )]),
23736        };
23737    }
23738    if let Some(ref local_var_str) = tenant_group {
23739        local_var_req_builder = match "multi" {
23740            "multi" => local_var_req_builder.query(
23741                &local_var_str
23742                    .into_iter()
23743                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
23744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23745            ),
23746            _ => local_var_req_builder.query(&[(
23747                "tenant_group",
23748                &local_var_str
23749                    .into_iter()
23750                    .map(|p| p.to_string())
23751                    .collect::<Vec<String>>()
23752                    .join(",")
23753                    .to_string(),
23754            )]),
23755        };
23756    }
23757    if let Some(ref local_var_str) = tenant_group__isnull {
23758        local_var_req_builder =
23759            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
23760    }
23761    if let Some(ref local_var_str) = tenant_group__n {
23762        local_var_req_builder = match "multi" {
23763            "multi" => local_var_req_builder.query(
23764                &local_var_str
23765                    .into_iter()
23766                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
23767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23768            ),
23769            _ => local_var_req_builder.query(&[(
23770                "tenant_group__n",
23771                &local_var_str
23772                    .into_iter()
23773                    .map(|p| p.to_string())
23774                    .collect::<Vec<String>>()
23775                    .join(",")
23776                    .to_string(),
23777            )]),
23778        };
23779    }
23780    if let Some(ref local_var_str) = tenant_id {
23781        local_var_req_builder = match "multi" {
23782            "multi" => local_var_req_builder.query(
23783                &local_var_str
23784                    .into_iter()
23785                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
23786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23787            ),
23788            _ => local_var_req_builder.query(&[(
23789                "tenant_id",
23790                &local_var_str
23791                    .into_iter()
23792                    .map(|p| p.to_string())
23793                    .collect::<Vec<String>>()
23794                    .join(",")
23795                    .to_string(),
23796            )]),
23797        };
23798    }
23799    if let Some(ref local_var_str) = tenant_id__isnull {
23800        local_var_req_builder =
23801            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
23802    }
23803    if let Some(ref local_var_str) = tenant_id__n {
23804        local_var_req_builder = match "multi" {
23805            "multi" => local_var_req_builder.query(
23806                &local_var_str
23807                    .into_iter()
23808                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
23809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23810            ),
23811            _ => local_var_req_builder.query(&[(
23812                "tenant_id__n",
23813                &local_var_str
23814                    .into_iter()
23815                    .map(|p| p.to_string())
23816                    .collect::<Vec<String>>()
23817                    .join(",")
23818                    .to_string(),
23819            )]),
23820        };
23821    }
23822    if let Some(ref local_var_str) = virtual_device_contexts {
23823        local_var_req_builder = match "multi" {
23824            "multi" => local_var_req_builder.query(
23825                &local_var_str
23826                    .into_iter()
23827                    .map(|p| ("virtual_device_contexts".to_owned(), p.to_string()))
23828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23829            ),
23830            _ => local_var_req_builder.query(&[(
23831                "virtual_device_contexts",
23832                &local_var_str
23833                    .into_iter()
23834                    .map(|p| p.to_string())
23835                    .collect::<Vec<String>>()
23836                    .join(",")
23837                    .to_string(),
23838            )]),
23839        };
23840    }
23841    if let Some(ref local_var_str) = virtual_device_contexts__n {
23842        local_var_req_builder = match "multi" {
23843            "multi" => local_var_req_builder.query(
23844                &local_var_str
23845                    .into_iter()
23846                    .map(|p| ("virtual_device_contexts__n".to_owned(), p.to_string()))
23847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23848            ),
23849            _ => local_var_req_builder.query(&[(
23850                "virtual_device_contexts__n",
23851                &local_var_str
23852                    .into_iter()
23853                    .map(|p| p.to_string())
23854                    .collect::<Vec<String>>()
23855                    .join(",")
23856                    .to_string(),
23857            )]),
23858        };
23859    }
23860    if let Some(ref local_var_str) = virtual_machines {
23861        local_var_req_builder = match "multi" {
23862            "multi" => local_var_req_builder.query(
23863                &local_var_str
23864                    .into_iter()
23865                    .map(|p| ("virtual_machines".to_owned(), p.to_string()))
23866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23867            ),
23868            _ => local_var_req_builder.query(&[(
23869                "virtual_machines",
23870                &local_var_str
23871                    .into_iter()
23872                    .map(|p| p.to_string())
23873                    .collect::<Vec<String>>()
23874                    .join(",")
23875                    .to_string(),
23876            )]),
23877        };
23878    }
23879    if let Some(ref local_var_str) = virtual_machines__n {
23880        local_var_req_builder = match "multi" {
23881            "multi" => local_var_req_builder.query(
23882                &local_var_str
23883                    .into_iter()
23884                    .map(|p| ("virtual_machines__n".to_owned(), p.to_string()))
23885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23886            ),
23887            _ => local_var_req_builder.query(&[(
23888                "virtual_machines__n",
23889                &local_var_str
23890                    .into_iter()
23891                    .map(|p| p.to_string())
23892                    .collect::<Vec<String>>()
23893                    .join(",")
23894                    .to_string(),
23895            )]),
23896        };
23897    }
23898    if let Some(ref local_var_str) = depth {
23899        local_var_req_builder =
23900            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
23901    }
23902    if let Some(ref local_var_str) = exclude_m2m {
23903        local_var_req_builder =
23904            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
23905    }
23906    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23907        local_var_req_builder =
23908            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23909    }
23910    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23911        let local_var_key = local_var_apikey.key.clone();
23912        let local_var_value = match local_var_apikey.prefix {
23913            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23914            None => local_var_key,
23915        };
23916        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23917    };
23918
23919    let local_var_req = local_var_req_builder.build()?;
23920    let local_var_resp = local_var_client.execute(local_var_req).await?;
23921
23922    let local_var_status = local_var_resp.status();
23923    let local_var_content = local_var_resp.text().await?;
23924
23925    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23926        serde_json::from_str(&local_var_content).map_err(Error::from)
23927    } else {
23928        let local_var_entity: Option<IpamVrfsListError> =
23929            serde_json::from_str(&local_var_content).ok();
23930        let local_var_error = ResponseContent {
23931            status: local_var_status,
23932            content: local_var_content,
23933            entity: local_var_entity,
23934        };
23935        Err(Error::ResponseError(local_var_error))
23936    }
23937}
23938
23939/// API methods for returning or creating notes on an object.
23940pub async fn ipam_vrfs_notes_create(
23941    configuration: &configuration::Configuration,
23942    id: &str,
23943    note_input_request: crate::models::NoteInputRequest,
23944    format: Option<&str>,
23945) -> Result<crate::models::Note, Error<IpamVrfsNotesCreateError>> {
23946    let local_var_configuration = configuration;
23947
23948    let local_var_client = &local_var_configuration.client;
23949
23950    let local_var_uri_str = format!(
23951        "{}/ipam/vrfs/{id}/notes/",
23952        local_var_configuration.base_path,
23953        id = crate::apis::urlencode(id)
23954    );
23955    let mut local_var_req_builder =
23956        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
23957
23958    if let Some(ref local_var_str) = format {
23959        local_var_req_builder =
23960            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
23961    }
23962    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23963        local_var_req_builder =
23964            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23965    }
23966    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23967        let local_var_key = local_var_apikey.key.clone();
23968        let local_var_value = match local_var_apikey.prefix {
23969            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23970            None => local_var_key,
23971        };
23972        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23973    };
23974    local_var_req_builder = local_var_req_builder.json(&note_input_request);
23975
23976    let local_var_req = local_var_req_builder.build()?;
23977    let local_var_resp = local_var_client.execute(local_var_req).await?;
23978
23979    let local_var_status = local_var_resp.status();
23980    let local_var_content = local_var_resp.text().await?;
23981
23982    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23983        serde_json::from_str(&local_var_content).map_err(Error::from)
23984    } else {
23985        let local_var_entity: Option<IpamVrfsNotesCreateError> =
23986            serde_json::from_str(&local_var_content).ok();
23987        let local_var_error = ResponseContent {
23988            status: local_var_status,
23989            content: local_var_content,
23990            entity: local_var_entity,
23991        };
23992        Err(Error::ResponseError(local_var_error))
23993    }
23994}
23995
23996/// API methods for returning or creating notes on an object.
23997pub async fn ipam_vrfs_notes_list(
23998    configuration: &configuration::Configuration,
23999    id: &str,
24000    format: Option<&str>,
24001    limit: Option<i32>,
24002    offset: Option<i32>,
24003    depth: Option<i32>,
24004    exclude_m2m: Option<bool>,
24005) -> Result<crate::models::PaginatedNoteList, Error<IpamVrfsNotesListError>> {
24006    let local_var_configuration = configuration;
24007
24008    let local_var_client = &local_var_configuration.client;
24009
24010    let local_var_uri_str = format!(
24011        "{}/ipam/vrfs/{id}/notes/",
24012        local_var_configuration.base_path,
24013        id = crate::apis::urlencode(id)
24014    );
24015    let mut local_var_req_builder =
24016        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
24017
24018    if let Some(ref local_var_str) = format {
24019        local_var_req_builder =
24020            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
24021    }
24022    if let Some(ref local_var_str) = limit {
24023        local_var_req_builder =
24024            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
24025    }
24026    if let Some(ref local_var_str) = offset {
24027        local_var_req_builder =
24028            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
24029    }
24030    if let Some(ref local_var_str) = depth {
24031        local_var_req_builder =
24032            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
24033    }
24034    if let Some(ref local_var_str) = exclude_m2m {
24035        local_var_req_builder =
24036            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
24037    }
24038    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
24039        local_var_req_builder =
24040            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
24041    }
24042    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
24043        let local_var_key = local_var_apikey.key.clone();
24044        let local_var_value = match local_var_apikey.prefix {
24045            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
24046            None => local_var_key,
24047        };
24048        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
24049    };
24050
24051    let local_var_req = local_var_req_builder.build()?;
24052    let local_var_resp = local_var_client.execute(local_var_req).await?;
24053
24054    let local_var_status = local_var_resp.status();
24055    let local_var_content = local_var_resp.text().await?;
24056
24057    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
24058        serde_json::from_str(&local_var_content).map_err(Error::from)
24059    } else {
24060        let local_var_entity: Option<IpamVrfsNotesListError> =
24061            serde_json::from_str(&local_var_content).ok();
24062        let local_var_error = ResponseContent {
24063            status: local_var_status,
24064            content: local_var_content,
24065            entity: local_var_entity,
24066        };
24067        Err(Error::ResponseError(local_var_error))
24068    }
24069}
24070
24071/// Partial update a VRF object.
24072pub async fn ipam_vrfs_partial_update(
24073    configuration: &configuration::Configuration,
24074    id: &str,
24075    format: Option<&str>,
24076    patched_vrf_request: Option<crate::models::PatchedVrfRequest>,
24077) -> Result<crate::models::Vrf, Error<IpamVrfsPartialUpdateError>> {
24078    let local_var_configuration = configuration;
24079
24080    let local_var_client = &local_var_configuration.client;
24081
24082    let local_var_uri_str = format!(
24083        "{}/ipam/vrfs/{id}/",
24084        local_var_configuration.base_path,
24085        id = crate::apis::urlencode(id)
24086    );
24087    let mut local_var_req_builder =
24088        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
24089
24090    if let Some(ref local_var_str) = format {
24091        local_var_req_builder =
24092            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
24093    }
24094    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
24095        local_var_req_builder =
24096            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
24097    }
24098    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
24099        let local_var_key = local_var_apikey.key.clone();
24100        let local_var_value = match local_var_apikey.prefix {
24101            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
24102            None => local_var_key,
24103        };
24104        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
24105    };
24106    local_var_req_builder = local_var_req_builder.json(&patched_vrf_request);
24107
24108    let local_var_req = local_var_req_builder.build()?;
24109    let local_var_resp = local_var_client.execute(local_var_req).await?;
24110
24111    let local_var_status = local_var_resp.status();
24112    let local_var_content = local_var_resp.text().await?;
24113
24114    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
24115        serde_json::from_str(&local_var_content).map_err(Error::from)
24116    } else {
24117        let local_var_entity: Option<IpamVrfsPartialUpdateError> =
24118            serde_json::from_str(&local_var_content).ok();
24119        let local_var_error = ResponseContent {
24120            status: local_var_status,
24121            content: local_var_content,
24122            entity: local_var_entity,
24123        };
24124        Err(Error::ResponseError(local_var_error))
24125    }
24126}
24127
24128/// Retrieve a VRF object.
24129pub async fn ipam_vrfs_retrieve(
24130    configuration: &configuration::Configuration,
24131    id: &str,
24132    format: Option<&str>,
24133    depth: Option<i32>,
24134    exclude_m2m: Option<bool>,
24135) -> Result<crate::models::Vrf, Error<IpamVrfsRetrieveError>> {
24136    let local_var_configuration = configuration;
24137
24138    let local_var_client = &local_var_configuration.client;
24139
24140    let local_var_uri_str = format!(
24141        "{}/ipam/vrfs/{id}/",
24142        local_var_configuration.base_path,
24143        id = crate::apis::urlencode(id)
24144    );
24145    let mut local_var_req_builder =
24146        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
24147
24148    if let Some(ref local_var_str) = format {
24149        local_var_req_builder =
24150            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
24151    }
24152    if let Some(ref local_var_str) = depth {
24153        local_var_req_builder =
24154            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
24155    }
24156    if let Some(ref local_var_str) = exclude_m2m {
24157        local_var_req_builder =
24158            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
24159    }
24160    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
24161        local_var_req_builder =
24162            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
24163    }
24164    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
24165        let local_var_key = local_var_apikey.key.clone();
24166        let local_var_value = match local_var_apikey.prefix {
24167            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
24168            None => local_var_key,
24169        };
24170        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
24171    };
24172
24173    let local_var_req = local_var_req_builder.build()?;
24174    let local_var_resp = local_var_client.execute(local_var_req).await?;
24175
24176    let local_var_status = local_var_resp.status();
24177    let local_var_content = local_var_resp.text().await?;
24178
24179    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
24180        serde_json::from_str(&local_var_content).map_err(Error::from)
24181    } else {
24182        let local_var_entity: Option<IpamVrfsRetrieveError> =
24183            serde_json::from_str(&local_var_content).ok();
24184        let local_var_error = ResponseContent {
24185            status: local_var_status,
24186            content: local_var_content,
24187            entity: local_var_entity,
24188        };
24189        Err(Error::ResponseError(local_var_error))
24190    }
24191}
24192
24193/// Update a VRF object.
24194pub async fn ipam_vrfs_update(
24195    configuration: &configuration::Configuration,
24196    id: &str,
24197    vrf_request: crate::models::VrfRequest,
24198    format: Option<&str>,
24199) -> Result<crate::models::Vrf, Error<IpamVrfsUpdateError>> {
24200    let local_var_configuration = configuration;
24201
24202    let local_var_client = &local_var_configuration.client;
24203
24204    let local_var_uri_str = format!(
24205        "{}/ipam/vrfs/{id}/",
24206        local_var_configuration.base_path,
24207        id = crate::apis::urlencode(id)
24208    );
24209    let mut local_var_req_builder =
24210        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
24211
24212    if let Some(ref local_var_str) = format {
24213        local_var_req_builder =
24214            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
24215    }
24216    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
24217        local_var_req_builder =
24218            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
24219    }
24220    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
24221        let local_var_key = local_var_apikey.key.clone();
24222        let local_var_value = match local_var_apikey.prefix {
24223            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
24224            None => local_var_key,
24225        };
24226        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
24227    };
24228    local_var_req_builder = local_var_req_builder.json(&vrf_request);
24229
24230    let local_var_req = local_var_req_builder.build()?;
24231    let local_var_resp = local_var_client.execute(local_var_req).await?;
24232
24233    let local_var_status = local_var_resp.status();
24234    let local_var_content = local_var_resp.text().await?;
24235
24236    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
24237        serde_json::from_str(&local_var_content).map_err(Error::from)
24238    } else {
24239        let local_var_entity: Option<IpamVrfsUpdateError> =
24240            serde_json::from_str(&local_var_content).ok();
24241        let local_var_error = ResponseContent {
24242            status: local_var_status,
24243            content: local_var_content,
24244            entity: local_var_entity,
24245        };
24246        Err(Error::ResponseError(local_var_error))
24247    }
24248}
nautobot_openapi/apis/ipam_api.rs

nautobot_openapi/apis/
ipam_api.rs
